SymbolFilePDB.cpp revision 360784 
1//===-- SymbolFilePDB.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 "SymbolFilePDB.h"
10
11#include "PDBASTParser.h"
12#include "PDBLocationToDWARFExpression.h"
13
14#include "clang/Lex/Lexer.h"
15
16#include "lldb/Core/Module.h"
17#include "lldb/Core/PluginManager.h"
18#include "lldb/Symbol/ClangASTContext.h"
19#include "lldb/Symbol/CompileUnit.h"
20#include "lldb/Symbol/LineTable.h"
21#include "lldb/Symbol/ObjectFile.h"
22#include "lldb/Symbol/SymbolContext.h"
23#include "lldb/Symbol/SymbolVendor.h"
24#include "lldb/Symbol/TypeList.h"
25#include "lldb/Symbol/TypeMap.h"
26#include "lldb/Symbol/Variable.h"
27#include "lldb/Utility/Log.h"
28#include "lldb/Utility/RegularExpression.h"
29
30#include "llvm/DebugInfo/PDB/GenericError.h"
31#include "llvm/DebugInfo/PDB/IPDBDataStream.h"
32#include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
33#include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
34#include "llvm/DebugInfo/PDB/IPDBSectionContrib.h"
35#include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
36#include "llvm/DebugInfo/PDB/IPDBTable.h"
37#include "llvm/DebugInfo/PDB/PDBSymbol.h"
38#include "llvm/DebugInfo/PDB/PDBSymbolBlock.h"
39#include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
40#include "llvm/DebugInfo/PDB/PDBSymbolCompilandDetails.h"
41#include "llvm/DebugInfo/PDB/PDBSymbolData.h"
42#include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
43#include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
44#include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugEnd.h"
45#include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugStart.h"
46#include "llvm/DebugInfo/PDB/PDBSymbolPublicSymbol.h"
47#include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
48#include "llvm/DebugInfo/PDB/PDBSymbolTypeTypedef.h"
49#include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h"
50
51#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
52#include "Plugins/Language/CPlusPlus/MSVCUndecoratedNameParser.h"
53#include "Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h"
54
55#include <regex>
56
57using namespace lldb;
58using namespace lldb_private;
59using namespace llvm::pdb;
60
61char SymbolFilePDB::ID;
62
63namespace {
64lldb::LanguageType TranslateLanguage(PDB_Lang lang) {
65  switch (lang) {
66  case PDB_Lang::Cpp:
67    return lldb::LanguageType::eLanguageTypeC_plus_plus;
68  case PDB_Lang::C:
69    return lldb::LanguageType::eLanguageTypeC;
70  case PDB_Lang::Swift:
71    return lldb::LanguageType::eLanguageTypeSwift;
72  default:
73    return lldb::LanguageType::eLanguageTypeUnknown;
74  }
75}
76
77bool ShouldAddLine(uint32_t requested_line, uint32_t actual_line,
78                   uint32_t addr_length) {
79  return ((requested_line == 0 || actual_line == requested_line) &&
80          addr_length > 0);
81}
82} // namespace
83
84static bool ShouldUseNativeReader() {
85#if defined(_WIN32)
86  llvm::StringRef use_native = ::getenv("LLDB_USE_NATIVE_PDB_READER");
87  return use_native.equals_lower("on") || use_native.equals_lower("yes") ||
88         use_native.equals_lower("1") || use_native.equals_lower("true");
89#else
90  return true;
91#endif
92}
93
94void SymbolFilePDB::Initialize() {
95  if (ShouldUseNativeReader()) {
96    npdb::SymbolFileNativePDB::Initialize();
97  } else {
98    PluginManager::RegisterPlugin(GetPluginNameStatic(),
99                                  GetPluginDescriptionStatic(), CreateInstance,
100                                  DebuggerInitialize);
101  }
102}
103
104void SymbolFilePDB::Terminate() {
105  if (ShouldUseNativeReader()) {
106    npdb::SymbolFileNativePDB::Terminate();
107  } else {
108    PluginManager::UnregisterPlugin(CreateInstance);
109  }
110}
111
112void SymbolFilePDB::DebuggerInitialize(lldb_private::Debugger &debugger) {}
113
114lldb_private::ConstString SymbolFilePDB::GetPluginNameStatic() {
115  static ConstString g_name("pdb");
116  return g_name;
117}
118
119const char *SymbolFilePDB::GetPluginDescriptionStatic() {
120  return "Microsoft PDB debug symbol file reader.";
121}
122
123lldb_private::SymbolFile *
124SymbolFilePDB::CreateInstance(ObjectFileSP objfile_sp) {
125  return new SymbolFilePDB(std::move(objfile_sp));
126}
127
128SymbolFilePDB::SymbolFilePDB(lldb::ObjectFileSP objfile_sp)
129    : SymbolFile(std::move(objfile_sp)), m_session_up(), m_global_scope_up() {}
130
131SymbolFilePDB::~SymbolFilePDB() {}
132
133uint32_t SymbolFilePDB::CalculateAbilities() {
134  uint32_t abilities = 0;
135  if (!m_objfile_sp)
136    return 0;
137
138  if (!m_session_up) {
139    // Lazily load and match the PDB file, but only do this once.
140    std::string exePath = m_objfile_sp->GetFileSpec().GetPath();
141    auto error = loadDataForEXE(PDB_ReaderType::DIA, llvm::StringRef(exePath),
142                                m_session_up);
143    if (error) {
144      llvm::consumeError(std::move(error));
145      auto module_sp = m_objfile_sp->GetModule();
146      if (!module_sp)
147        return 0;
148      // See if any symbol file is specified through `--symfile` option.
149      FileSpec symfile = module_sp->GetSymbolFileFileSpec();
150      if (!symfile)
151        return 0;
152      error = loadDataForPDB(PDB_ReaderType::DIA,
153                             llvm::StringRef(symfile.GetPath()), m_session_up);
154      if (error) {
155        llvm::consumeError(std::move(error));
156        return 0;
157      }
158    }
159  }
160  if (!m_session_up)
161    return 0;
162
163  auto enum_tables_up = m_session_up->getEnumTables();
164  if (!enum_tables_up)
165    return 0;
166  while (auto table_up = enum_tables_up->getNext()) {
167    if (table_up->getItemCount() == 0)
168      continue;
169    auto type = table_up->getTableType();
170    switch (type) {
171    case PDB_TableType::Symbols:
172      // This table represents a store of symbols with types listed in
173      // PDBSym_Type
174      abilities |= (CompileUnits | Functions | Blocks | GlobalVariables |
175                    LocalVariables | VariableTypes);
176      break;
177    case PDB_TableType::LineNumbers:
178      abilities |= LineTables;
179      break;
180    default:
181      break;
182    }
183  }
184  return abilities;
185}
186
187void SymbolFilePDB::InitializeObject() {
188  lldb::addr_t obj_load_address =
189      m_objfile_sp->GetBaseAddress().GetFileAddress();
190  lldbassert(obj_load_address && obj_load_address != LLDB_INVALID_ADDRESS);
191  m_session_up->setLoadAddress(obj_load_address);
192  if (!m_global_scope_up)
193    m_global_scope_up = m_session_up->getGlobalScope();
194  lldbassert(m_global_scope_up.get());
195}
196
197uint32_t SymbolFilePDB::CalculateNumCompileUnits() {
198  auto compilands = m_global_scope_up->findAllChildren<PDBSymbolCompiland>();
199  if (!compilands)
200    return 0;
201
202  // The linker could link *.dll (compiland language = LINK), or import
203  // *.dll. For example, a compiland with name `Import:KERNEL32.dll` could be
204  // found as a child of the global scope (PDB executable). Usually, such
205  // compilands contain `thunk` symbols in which we are not interested for
206  // now. However we still count them in the compiland list. If we perform
207  // any compiland related activity, like finding symbols through
208  // llvm::pdb::IPDBSession methods, such compilands will all be searched
209  // automatically no matter whether we include them or not.
210  uint32_t compile_unit_count = compilands->getChildCount();
211
212  // The linker can inject an additional "dummy" compilation unit into the
213  // PDB. Ignore this special compile unit for our purposes, if it is there.
214  // It is always the last one.
215  auto last_compiland_up = compilands->getChildAtIndex(compile_unit_count - 1);
216  lldbassert(last_compiland_up.get());
217  std::string name = last_compiland_up->getName();
218  if (name == "* Linker *")
219    --compile_unit_count;
220  return compile_unit_count;
221}
222
223void SymbolFilePDB::GetCompileUnitIndex(
224    const llvm::pdb::PDBSymbolCompiland &pdb_compiland, uint32_t &index) {
225  auto results_up = m_global_scope_up->findAllChildren<PDBSymbolCompiland>();
226  if (!results_up)
227    return;
228  auto uid = pdb_compiland.getSymIndexId();
229  for (uint32_t cu_idx = 0; cu_idx < GetNumCompileUnits(); ++cu_idx) {
230    auto compiland_up = results_up->getChildAtIndex(cu_idx);
231    if (!compiland_up)
232      continue;
233    if (compiland_up->getSymIndexId() == uid) {
234      index = cu_idx;
235      return;
236    }
237  }
238  index = UINT32_MAX;
239  return;
240}
241
242std::unique_ptr<llvm::pdb::PDBSymbolCompiland>
243SymbolFilePDB::GetPDBCompilandByUID(uint32_t uid) {
244  return m_session_up->getConcreteSymbolById<PDBSymbolCompiland>(uid);
245}
246
247lldb::CompUnitSP SymbolFilePDB::ParseCompileUnitAtIndex(uint32_t index) {
248  if (index >= GetNumCompileUnits())
249    return CompUnitSP();
250
251  // Assuming we always retrieve same compilands listed in same order through
252  // `PDBSymbolExe::findAllChildren` method, otherwise using `index` to get a
253  // compile unit makes no sense.
254  auto results = m_global_scope_up->findAllChildren<PDBSymbolCompiland>();
255  if (!results)
256    return CompUnitSP();
257  auto compiland_up = results->getChildAtIndex(index);
258  if (!compiland_up)
259    return CompUnitSP();
260  return ParseCompileUnitForUID(compiland_up->getSymIndexId(), index);
261}
262
263lldb::LanguageType SymbolFilePDB::ParseLanguage(CompileUnit &comp_unit) {
264  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
265  auto compiland_up = GetPDBCompilandByUID(comp_unit.GetID());
266  if (!compiland_up)
267    return lldb::eLanguageTypeUnknown;
268  auto details = compiland_up->findOneChild<PDBSymbolCompilandDetails>();
269  if (!details)
270    return lldb::eLanguageTypeUnknown;
271  return TranslateLanguage(details->getLanguage());
272}
273
274lldb_private::Function *
275SymbolFilePDB::ParseCompileUnitFunctionForPDBFunc(const PDBSymbolFunc &pdb_func,
276                                                  CompileUnit &comp_unit) {
277  if (FunctionSP result = comp_unit.FindFunctionByUID(pdb_func.getSymIndexId()))
278    return result.get();
279
280  auto file_vm_addr = pdb_func.getVirtualAddress();
281  if (file_vm_addr == LLDB_INVALID_ADDRESS || file_vm_addr == 0)
282    return nullptr;
283
284  auto func_length = pdb_func.getLength();
285  AddressRange func_range =
286      AddressRange(file_vm_addr, func_length,
287                   GetObjectFile()->GetModule()->GetSectionList());
288  if (!func_range.GetBaseAddress().IsValid())
289    return nullptr;
290
291  lldb_private::Type *func_type = ResolveTypeUID(pdb_func.getSymIndexId());
292  if (!func_type)
293    return nullptr;
294
295  user_id_t func_type_uid = pdb_func.getSignatureId();
296
297  Mangled mangled = GetMangledForPDBFunc(pdb_func);
298
299  FunctionSP func_sp =
300      std::make_shared<Function>(&comp_unit, pdb_func.getSymIndexId(),
301                                 func_type_uid, mangled, func_type, func_range);
302
303  comp_unit.AddFunction(func_sp);
304
305  LanguageType lang = ParseLanguage(comp_unit);
306  auto type_system_or_err = GetTypeSystemForLanguage(lang);
307  if (auto err = type_system_or_err.takeError()) {
308    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
309                   std::move(err), "Unable to parse PDBFunc");
310    return nullptr;
311  }
312
313  ClangASTContext *clang_type_system =
314    llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
315  if (!clang_type_system)
316    return nullptr;
317  clang_type_system->GetPDBParser()->GetDeclForSymbol(pdb_func);
318
319  return func_sp.get();
320}
321
322size_t SymbolFilePDB::ParseFunctions(CompileUnit &comp_unit) {
323  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
324  size_t func_added = 0;
325  auto compiland_up = GetPDBCompilandByUID(comp_unit.GetID());
326  if (!compiland_up)
327    return 0;
328  auto results_up = compiland_up->findAllChildren<PDBSymbolFunc>();
329  if (!results_up)
330    return 0;
331  while (auto pdb_func_up = results_up->getNext()) {
332    auto func_sp = comp_unit.FindFunctionByUID(pdb_func_up->getSymIndexId());
333    if (!func_sp) {
334      if (ParseCompileUnitFunctionForPDBFunc(*pdb_func_up, comp_unit))
335        ++func_added;
336    }
337  }
338  return func_added;
339}
340
341bool SymbolFilePDB::ParseLineTable(CompileUnit &comp_unit) {
342  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
343  if (comp_unit.GetLineTable())
344    return true;
345  return ParseCompileUnitLineTable(comp_unit, 0);
346}
347
348bool SymbolFilePDB::ParseDebugMacros(CompileUnit &comp_unit) {
349  // PDB doesn't contain information about macros
350  return false;
351}
352
353bool SymbolFilePDB::ParseSupportFiles(
354    CompileUnit &comp_unit, lldb_private::FileSpecList &support_files) {
355
356  // In theory this is unnecessary work for us, because all of this information
357  // is easily (and quickly) accessible from DebugInfoPDB, so caching it a
358  // second time seems like a waste.  Unfortunately, there's no good way around
359  // this short of a moderate refactor since SymbolVendor depends on being able
360  // to cache this list.
361  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
362  auto compiland_up = GetPDBCompilandByUID(comp_unit.GetID());
363  if (!compiland_up)
364    return false;
365  auto files = m_session_up->getSourceFilesForCompiland(*compiland_up);
366  if (!files || files->getChildCount() == 0)
367    return false;
368
369  while (auto file = files->getNext()) {
370    FileSpec spec(file->getFileName(), FileSpec::Style::windows);
371    support_files.AppendIfUnique(spec);
372  }
373
374  return true;
375}
376
377bool SymbolFilePDB::ParseImportedModules(
378    const lldb_private::SymbolContext &sc,
379    std::vector<SourceModule> &imported_modules) {
380  // PDB does not yet support module debug info
381  return false;
382}
383
384static size_t ParseFunctionBlocksForPDBSymbol(
385    uint64_t func_file_vm_addr, const llvm::pdb::PDBSymbol *pdb_symbol,
386    lldb_private::Block *parent_block, bool is_top_parent) {
387  assert(pdb_symbol && parent_block);
388
389  size_t num_added = 0;
390  switch (pdb_symbol->getSymTag()) {
391  case PDB_SymType::Block:
392  case PDB_SymType::Function: {
393    Block *block = nullptr;
394    auto &raw_sym = pdb_symbol->getRawSymbol();
395    if (auto *pdb_func = llvm::dyn_cast<PDBSymbolFunc>(pdb_symbol)) {
396      if (pdb_func->hasNoInlineAttribute())
397        break;
398      if (is_top_parent)
399        block = parent_block;
400      else
401        break;
402    } else if (llvm::dyn_cast<PDBSymbolBlock>(pdb_symbol)) {
403      auto uid = pdb_symbol->getSymIndexId();
404      if (parent_block->FindBlockByID(uid))
405        break;
406      if (raw_sym.getVirtualAddress() < func_file_vm_addr)
407        break;
408
409      auto block_sp = std::make_shared<Block>(pdb_symbol->getSymIndexId());
410      parent_block->AddChild(block_sp);
411      block = block_sp.get();
412    } else
413      llvm_unreachable("Unexpected PDB symbol!");
414
415    block->AddRange(Block::Range(
416        raw_sym.getVirtualAddress() - func_file_vm_addr, raw_sym.getLength()));
417    block->FinalizeRanges();
418    ++num_added;
419
420    auto results_up = pdb_symbol->findAllChildren();
421    if (!results_up)
422      break;
423    while (auto symbol_up = results_up->getNext()) {
424      num_added += ParseFunctionBlocksForPDBSymbol(
425          func_file_vm_addr, symbol_up.get(), block, false);
426    }
427  } break;
428  default:
429    break;
430  }
431  return num_added;
432}
433
434size_t SymbolFilePDB::ParseBlocksRecursive(Function &func) {
435  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
436  size_t num_added = 0;
437  auto uid = func.GetID();
438  auto pdb_func_up = m_session_up->getConcreteSymbolById<PDBSymbolFunc>(uid);
439  if (!pdb_func_up)
440    return 0;
441  Block &parent_block = func.GetBlock(false);
442  num_added = ParseFunctionBlocksForPDBSymbol(
443      pdb_func_up->getVirtualAddress(), pdb_func_up.get(), &parent_block, true);
444  return num_added;
445}
446
447size_t SymbolFilePDB::ParseTypes(CompileUnit &comp_unit) {
448  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
449
450  size_t num_added = 0;
451  auto compiland = GetPDBCompilandByUID(comp_unit.GetID());
452  if (!compiland)
453    return 0;
454
455  auto ParseTypesByTagFn = [&num_added, this](const PDBSymbol &raw_sym) {
456    std::unique_ptr<IPDBEnumSymbols> results;
457    PDB_SymType tags_to_search[] = {PDB_SymType::Enum, PDB_SymType::Typedef,
458                                    PDB_SymType::UDT};
459    for (auto tag : tags_to_search) {
460      results = raw_sym.findAllChildren(tag);
461      if (!results || results->getChildCount() == 0)
462        continue;
463      while (auto symbol = results->getNext()) {
464        switch (symbol->getSymTag()) {
465        case PDB_SymType::Enum:
466        case PDB_SymType::UDT:
467        case PDB_SymType::Typedef:
468          break;
469        default:
470          continue;
471        }
472
473        // This should cause the type to get cached and stored in the `m_types`
474        // lookup.
475        if (auto type = ResolveTypeUID(symbol->getSymIndexId())) {
476          // Resolve the type completely to avoid a completion
477          // (and so a list change, which causes an iterators invalidation)
478          // during a TypeList dumping
479          type->GetFullCompilerType();
480          ++num_added;
481        }
482      }
483    }
484  };
485
486  ParseTypesByTagFn(*compiland);
487
488  // Also parse global types particularly coming from this compiland.
489  // Unfortunately, PDB has no compiland information for each global type. We
490  // have to parse them all. But ensure we only do this once.
491  static bool parse_all_global_types = false;
492  if (!parse_all_global_types) {
493    ParseTypesByTagFn(*m_global_scope_up);
494    parse_all_global_types = true;
495  }
496  return num_added;
497}
498
499size_t
500SymbolFilePDB::ParseVariablesForContext(const lldb_private::SymbolContext &sc) {
501  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
502  if (!sc.comp_unit)
503    return 0;
504
505  size_t num_added = 0;
506  if (sc.function) {
507    auto pdb_func = m_session_up->getConcreteSymbolById<PDBSymbolFunc>(
508        sc.function->GetID());
509    if (!pdb_func)
510      return 0;
511
512    num_added += ParseVariables(sc, *pdb_func);
513    sc.function->GetBlock(false).SetDidParseVariables(true, true);
514  } else if (sc.comp_unit) {
515    auto compiland = GetPDBCompilandByUID(sc.comp_unit->GetID());
516    if (!compiland)
517      return 0;
518
519    if (sc.comp_unit->GetVariableList(false))
520      return 0;
521
522    auto results = m_global_scope_up->findAllChildren<PDBSymbolData>();
523    if (results && results->getChildCount()) {
524      while (auto result = results->getNext()) {
525        auto cu_id = GetCompilandId(*result);
526        // FIXME: We are not able to determine variable's compile unit.
527        if (cu_id == 0)
528          continue;
529
530        if (cu_id == sc.comp_unit->GetID())
531          num_added += ParseVariables(sc, *result);
532      }
533    }
534
535    // FIXME: A `file static` or `global constant` variable appears both in
536    // compiland's children and global scope's children with unexpectedly
537    // different symbol's Id making it ambiguous.
538
539    // FIXME: 'local constant', for example, const char var[] = "abc", declared
540    // in a function scope, can't be found in PDB.
541
542    // Parse variables in this compiland.
543    num_added += ParseVariables(sc, *compiland);
544  }
545
546  return num_added;
547}
548
549lldb_private::Type *SymbolFilePDB::ResolveTypeUID(lldb::user_id_t type_uid) {
550  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
551  auto find_result = m_types.find(type_uid);
552  if (find_result != m_types.end())
553    return find_result->second.get();
554
555  auto type_system_or_err =
556      GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
557  if (auto err = type_system_or_err.takeError()) {
558    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
559                   std::move(err), "Unable to ResolveTypeUID");
560    return nullptr;
561  }
562
563  ClangASTContext *clang_type_system =
564      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
565  if (!clang_type_system)
566    return nullptr;
567  PDBASTParser *pdb = clang_type_system->GetPDBParser();
568  if (!pdb)
569    return nullptr;
570
571  auto pdb_type = m_session_up->getSymbolById(type_uid);
572  if (pdb_type == nullptr)
573    return nullptr;
574
575  lldb::TypeSP result = pdb->CreateLLDBTypeFromPDBType(*pdb_type);
576  if (result) {
577    m_types.insert(std::make_pair(type_uid, result));
578    GetTypeList().Insert(result);
579  }
580  return result.get();
581}
582
583llvm::Optional<SymbolFile::ArrayInfo> SymbolFilePDB::GetDynamicArrayInfoForUID(
584    lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
585  return llvm::None;
586}
587
588bool SymbolFilePDB::CompleteType(lldb_private::CompilerType &compiler_type) {
589  std::lock_guard<std::recursive_mutex> guard(
590      GetObjectFile()->GetModule()->GetMutex());
591
592  auto type_system_or_err =
593      GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
594  if (auto err = type_system_or_err.takeError()) {
595    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
596                   std::move(err), "Unable to get dynamic array info for UID");
597    return false;
598  }
599
600  ClangASTContext *clang_ast_ctx =
601      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
602
603  if (!clang_ast_ctx)
604    return false;
605
606  PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
607  if (!pdb)
608    return false;
609
610  return pdb->CompleteTypeFromPDB(compiler_type);
611}
612
613lldb_private::CompilerDecl SymbolFilePDB::GetDeclForUID(lldb::user_id_t uid) {
614  auto type_system_or_err =
615      GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
616  if (auto err = type_system_or_err.takeError()) {
617    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
618                   std::move(err), "Unable to get decl for UID");
619    return CompilerDecl();
620  }
621
622  ClangASTContext *clang_ast_ctx =
623      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
624  if (!clang_ast_ctx)
625    return CompilerDecl();
626
627  PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
628  if (!pdb)
629    return CompilerDecl();
630
631  auto symbol = m_session_up->getSymbolById(uid);
632  if (!symbol)
633    return CompilerDecl();
634
635  auto decl = pdb->GetDeclForSymbol(*symbol);
636  if (!decl)
637    return CompilerDecl();
638
639  return CompilerDecl(clang_ast_ctx, decl);
640}
641
642lldb_private::CompilerDeclContext
643SymbolFilePDB::GetDeclContextForUID(lldb::user_id_t uid) {
644  auto type_system_or_err =
645      GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
646  if (auto err = type_system_or_err.takeError()) {
647    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
648                   std::move(err), "Unable to get DeclContext for UID");
649    return CompilerDeclContext();
650  }
651
652  ClangASTContext *clang_ast_ctx =
653      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
654  if (!clang_ast_ctx)
655    return CompilerDeclContext();
656
657  PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
658  if (!pdb)
659    return CompilerDeclContext();
660
661  auto symbol = m_session_up->getSymbolById(uid);
662  if (!symbol)
663    return CompilerDeclContext();
664
665  auto decl_context = pdb->GetDeclContextForSymbol(*symbol);
666  if (!decl_context)
667    return GetDeclContextContainingUID(uid);
668
669  return clang_ast_ctx->CreateDeclContext(decl_context);
670}
671
672lldb_private::CompilerDeclContext
673SymbolFilePDB::GetDeclContextContainingUID(lldb::user_id_t uid) {
674  auto type_system_or_err =
675      GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
676  if (auto err = type_system_or_err.takeError()) {
677    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
678                   std::move(err), "Unable to get DeclContext containing UID");
679    return CompilerDeclContext();
680  }
681
682  ClangASTContext *clang_ast_ctx =
683      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
684  if (!clang_ast_ctx)
685    return CompilerDeclContext();
686
687  PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
688  if (!pdb)
689    return CompilerDeclContext();
690
691  auto symbol = m_session_up->getSymbolById(uid);
692  if (!symbol)
693    return CompilerDeclContext();
694
695  auto decl_context = pdb->GetDeclContextContainingSymbol(*symbol);
696  assert(decl_context);
697
698  return clang_ast_ctx->CreateDeclContext(decl_context);
699}
700
701void SymbolFilePDB::ParseDeclsForContext(
702    lldb_private::CompilerDeclContext decl_ctx) {
703  auto type_system_or_err =
704      GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
705  if (auto err = type_system_or_err.takeError()) {
706    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
707                   std::move(err), "Unable to parse decls for context");
708    return;
709  }
710
711  ClangASTContext *clang_ast_ctx =
712      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
713  if (!clang_ast_ctx)
714    return;
715
716  PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
717  if (!pdb)
718    return;
719
720  pdb->ParseDeclsForDeclContext(
721      static_cast<clang::DeclContext *>(decl_ctx.GetOpaqueDeclContext()));
722}
723
724uint32_t
725SymbolFilePDB::ResolveSymbolContext(const lldb_private::Address &so_addr,
726                                    SymbolContextItem resolve_scope,
727                                    lldb_private::SymbolContext &sc) {
728  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
729  uint32_t resolved_flags = 0;
730  if (resolve_scope & eSymbolContextCompUnit ||
731      resolve_scope & eSymbolContextVariable ||
732      resolve_scope & eSymbolContextFunction ||
733      resolve_scope & eSymbolContextBlock ||
734      resolve_scope & eSymbolContextLineEntry) {
735    auto cu_sp = GetCompileUnitContainsAddress(so_addr);
736    if (!cu_sp) {
737      if (resolved_flags & eSymbolContextVariable) {
738        // TODO: Resolve variables
739      }
740      return 0;
741    }
742    sc.comp_unit = cu_sp.get();
743    resolved_flags |= eSymbolContextCompUnit;
744    lldbassert(sc.module_sp == cu_sp->GetModule());
745  }
746
747  if (resolve_scope & eSymbolContextFunction ||
748      resolve_scope & eSymbolContextBlock) {
749    addr_t file_vm_addr = so_addr.GetFileAddress();
750    auto symbol_up =
751        m_session_up->findSymbolByAddress(file_vm_addr, PDB_SymType::Function);
752    if (symbol_up) {
753      auto *pdb_func = llvm::dyn_cast<PDBSymbolFunc>(symbol_up.get());
754      assert(pdb_func);
755      auto func_uid = pdb_func->getSymIndexId();
756      sc.function = sc.comp_unit->FindFunctionByUID(func_uid).get();
757      if (sc.function == nullptr)
758        sc.function =
759            ParseCompileUnitFunctionForPDBFunc(*pdb_func, *sc.comp_unit);
760      if (sc.function) {
761        resolved_flags |= eSymbolContextFunction;
762        if (resolve_scope & eSymbolContextBlock) {
763          auto block_symbol = m_session_up->findSymbolByAddress(
764              file_vm_addr, PDB_SymType::Block);
765          auto block_id = block_symbol ? block_symbol->getSymIndexId()
766                                       : sc.function->GetID();
767          sc.block = sc.function->GetBlock(true).FindBlockByID(block_id);
768          if (sc.block)
769            resolved_flags |= eSymbolContextBlock;
770        }
771      }
772    }
773  }
774
775  if (resolve_scope & eSymbolContextLineEntry) {
776    if (auto *line_table = sc.comp_unit->GetLineTable()) {
777      Address addr(so_addr);
778      if (line_table->FindLineEntryByAddress(addr, sc.line_entry))
779        resolved_flags |= eSymbolContextLineEntry;
780    }
781  }
782
783  return resolved_flags;
784}
785
786uint32_t SymbolFilePDB::ResolveSymbolContext(
787    const lldb_private::FileSpec &file_spec, uint32_t line, bool check_inlines,
788    SymbolContextItem resolve_scope, lldb_private::SymbolContextList &sc_list) {
789  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
790  const size_t old_size = sc_list.GetSize();
791  if (resolve_scope & lldb::eSymbolContextCompUnit) {
792    // Locate all compilation units with line numbers referencing the specified
793    // file.  For example, if `file_spec` is <vector>, then this should return
794    // all source files and header files that reference <vector>, either
795    // directly or indirectly.
796    auto compilands = m_session_up->findCompilandsForSourceFile(
797        file_spec.GetPath(), PDB_NameSearchFlags::NS_CaseInsensitive);
798
799    if (!compilands)
800      return 0;
801
802    // For each one, either find its previously parsed data or parse it afresh
803    // and add it to the symbol context list.
804    while (auto compiland = compilands->getNext()) {
805      // If we're not checking inlines, then don't add line information for
806      // this file unless the FileSpec matches. For inline functions, we don't
807      // have to match the FileSpec since they could be defined in headers
808      // other than file specified in FileSpec.
809      if (!check_inlines) {
810        std::string source_file = compiland->getSourceFileFullPath();
811        if (source_file.empty())
812          continue;
813        FileSpec this_spec(source_file, FileSpec::Style::windows);
814        bool need_full_match = !file_spec.GetDirectory().IsEmpty();
815        if (FileSpec::Compare(file_spec, this_spec, need_full_match) != 0)
816          continue;
817      }
818
819      SymbolContext sc;
820      auto cu = ParseCompileUnitForUID(compiland->getSymIndexId());
821      if (!cu)
822        continue;
823      sc.comp_unit = cu.get();
824      sc.module_sp = cu->GetModule();
825
826      // If we were asked to resolve line entries, add all entries to the line
827      // table that match the requested line (or all lines if `line` == 0).
828      if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock |
829                           eSymbolContextLineEntry)) {
830        bool has_line_table = ParseCompileUnitLineTable(*sc.comp_unit, line);
831
832        if ((resolve_scope & eSymbolContextLineEntry) && !has_line_table) {
833          // The query asks for line entries, but we can't get them for the
834          // compile unit. This is not normal for `line` = 0. So just assert
835          // it.
836          assert(line && "Couldn't get all line entries!\n");
837
838          // Current compiland does not have the requested line. Search next.
839          continue;
840        }
841
842        if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock)) {
843          if (!has_line_table)
844            continue;
845
846          auto *line_table = sc.comp_unit->GetLineTable();
847          lldbassert(line_table);
848
849          uint32_t num_line_entries = line_table->GetSize();
850          // Skip the terminal line entry.
851          --num_line_entries;
852
853          // If `line `!= 0, see if we can resolve function for each line entry
854          // in the line table.
855          for (uint32_t line_idx = 0; line && line_idx < num_line_entries;
856               ++line_idx) {
857            if (!line_table->GetLineEntryAtIndex(line_idx, sc.line_entry))
858              continue;
859
860            auto file_vm_addr =
861                sc.line_entry.range.GetBaseAddress().GetFileAddress();
862            if (file_vm_addr == LLDB_INVALID_ADDRESS || file_vm_addr == 0)
863              continue;
864
865            auto symbol_up = m_session_up->findSymbolByAddress(
866                file_vm_addr, PDB_SymType::Function);
867            if (symbol_up) {
868              auto func_uid = symbol_up->getSymIndexId();
869              sc.function = sc.comp_unit->FindFunctionByUID(func_uid).get();
870              if (sc.function == nullptr) {
871                auto pdb_func = llvm::dyn_cast<PDBSymbolFunc>(symbol_up.get());
872                assert(pdb_func);
873                sc.function = ParseCompileUnitFunctionForPDBFunc(*pdb_func,
874                                                                 *sc.comp_unit);
875              }
876              if (sc.function && (resolve_scope & eSymbolContextBlock)) {
877                Block &block = sc.function->GetBlock(true);
878                sc.block = block.FindBlockByID(sc.function->GetID());
879              }
880            }
881            sc_list.Append(sc);
882          }
883        } else if (has_line_table) {
884          // We can parse line table for the compile unit. But no query to
885          // resolve function or block. We append `sc` to the list anyway.
886          sc_list.Append(sc);
887        }
888      } else {
889        // No query for line entry, function or block. But we have a valid
890        // compile unit, append `sc` to the list.
891        sc_list.Append(sc);
892      }
893    }
894  }
895  return sc_list.GetSize() - old_size;
896}
897
898std::string SymbolFilePDB::GetMangledForPDBData(const PDBSymbolData &pdb_data) {
899  // Cache public names at first
900  if (m_public_names.empty())
901    if (auto result_up =
902            m_global_scope_up->findAllChildren(PDB_SymType::PublicSymbol))
903      while (auto symbol_up = result_up->getNext())
904        if (auto addr = symbol_up->getRawSymbol().getVirtualAddress())
905          m_public_names[addr] = symbol_up->getRawSymbol().getName();
906
907  // Look up the name in the cache
908  return m_public_names.lookup(pdb_data.getVirtualAddress());
909}
910
911VariableSP SymbolFilePDB::ParseVariableForPDBData(
912    const lldb_private::SymbolContext &sc,
913    const llvm::pdb::PDBSymbolData &pdb_data) {
914  VariableSP var_sp;
915  uint32_t var_uid = pdb_data.getSymIndexId();
916  auto result = m_variables.find(var_uid);
917  if (result != m_variables.end())
918    return result->second;
919
920  ValueType scope = eValueTypeInvalid;
921  bool is_static_member = false;
922  bool is_external = false;
923  bool is_artificial = false;
924
925  switch (pdb_data.getDataKind()) {
926  case PDB_DataKind::Global:
927    scope = eValueTypeVariableGlobal;
928    is_external = true;
929    break;
930  case PDB_DataKind::Local:
931    scope = eValueTypeVariableLocal;
932    break;
933  case PDB_DataKind::FileStatic:
934    scope = eValueTypeVariableStatic;
935    break;
936  case PDB_DataKind::StaticMember:
937    is_static_member = true;
938    scope = eValueTypeVariableStatic;
939    break;
940  case PDB_DataKind::Member:
941    scope = eValueTypeVariableStatic;
942    break;
943  case PDB_DataKind::Param:
944    scope = eValueTypeVariableArgument;
945    break;
946  case PDB_DataKind::Constant:
947    scope = eValueTypeConstResult;
948    break;
949  default:
950    break;
951  }
952
953  switch (pdb_data.getLocationType()) {
954  case PDB_LocType::TLS:
955    scope = eValueTypeVariableThreadLocal;
956    break;
957  case PDB_LocType::RegRel: {
958    // It is a `this` pointer.
959    if (pdb_data.getDataKind() == PDB_DataKind::ObjectPtr) {
960      scope = eValueTypeVariableArgument;
961      is_artificial = true;
962    }
963  } break;
964  default:
965    break;
966  }
967
968  Declaration decl;
969  if (!is_artificial && !pdb_data.isCompilerGenerated()) {
970    if (auto lines = pdb_data.getLineNumbers()) {
971      if (auto first_line = lines->getNext()) {
972        uint32_t src_file_id = first_line->getSourceFileId();
973        auto src_file = m_session_up->getSourceFileById(src_file_id);
974        if (src_file) {
975          FileSpec spec(src_file->getFileName());
976          decl.SetFile(spec);
977          decl.SetColumn(first_line->getColumnNumber());
978          decl.SetLine(first_line->getLineNumber());
979        }
980      }
981    }
982  }
983
984  Variable::RangeList ranges;
985  SymbolContextScope *context_scope = sc.comp_unit;
986  if (scope == eValueTypeVariableLocal || scope == eValueTypeVariableArgument) {
987    if (sc.function) {
988      Block &function_block = sc.function->GetBlock(true);
989      Block *block =
990          function_block.FindBlockByID(pdb_data.getLexicalParentId());
991      if (!block)
992        block = &function_block;
993
994      context_scope = block;
995
996      for (size_t i = 0, num_ranges = block->GetNumRanges(); i < num_ranges;
997           ++i) {
998        AddressRange range;
999        if (!block->GetRangeAtIndex(i, range))
1000          continue;
1001
1002        ranges.Append(range.GetBaseAddress().GetFileAddress(),
1003                      range.GetByteSize());
1004      }
1005    }
1006  }
1007
1008  SymbolFileTypeSP type_sp =
1009      std::make_shared<SymbolFileType>(*this, pdb_data.getTypeId());
1010
1011  auto var_name = pdb_data.getName();
1012  auto mangled = GetMangledForPDBData(pdb_data);
1013  auto mangled_cstr = mangled.empty() ? nullptr : mangled.c_str();
1014
1015  bool is_constant;
1016  DWARFExpression location = ConvertPDBLocationToDWARFExpression(
1017      GetObjectFile()->GetModule(), pdb_data, ranges, is_constant);
1018
1019  var_sp = std::make_shared<Variable>(
1020      var_uid, var_name.c_str(), mangled_cstr, type_sp, scope, context_scope,
1021      ranges, &decl, location, is_external, is_artificial, is_static_member);
1022  var_sp->SetLocationIsConstantValueData(is_constant);
1023
1024  m_variables.insert(std::make_pair(var_uid, var_sp));
1025  return var_sp;
1026}
1027
1028size_t
1029SymbolFilePDB::ParseVariables(const lldb_private::SymbolContext &sc,
1030                              const llvm::pdb::PDBSymbol &pdb_symbol,
1031                              lldb_private::VariableList *variable_list) {
1032  size_t num_added = 0;
1033
1034  if (auto pdb_data = llvm::dyn_cast<PDBSymbolData>(&pdb_symbol)) {
1035    VariableListSP local_variable_list_sp;
1036
1037    auto result = m_variables.find(pdb_data->getSymIndexId());
1038    if (result != m_variables.end()) {
1039      if (variable_list)
1040        variable_list->AddVariableIfUnique(result->second);
1041    } else {
1042      // Prepare right VariableList for this variable.
1043      if (auto lexical_parent = pdb_data->getLexicalParent()) {
1044        switch (lexical_parent->getSymTag()) {
1045        case PDB_SymType::Exe:
1046          assert(sc.comp_unit);
1047          LLVM_FALLTHROUGH;
1048        case PDB_SymType::Compiland: {
1049          if (sc.comp_unit) {
1050            local_variable_list_sp = sc.comp_unit->GetVariableList(false);
1051            if (!local_variable_list_sp) {
1052              local_variable_list_sp = std::make_shared<VariableList>();
1053              sc.comp_unit->SetVariableList(local_variable_list_sp);
1054            }
1055          }
1056        } break;
1057        case PDB_SymType::Block:
1058        case PDB_SymType::Function: {
1059          if (sc.function) {
1060            Block *block = sc.function->GetBlock(true).FindBlockByID(
1061                lexical_parent->getSymIndexId());
1062            if (block) {
1063              local_variable_list_sp = block->GetBlockVariableList(false);
1064              if (!local_variable_list_sp) {
1065                local_variable_list_sp = std::make_shared<VariableList>();
1066                block->SetVariableList(local_variable_list_sp);
1067              }
1068            }
1069          }
1070        } break;
1071        default:
1072          break;
1073        }
1074      }
1075
1076      if (local_variable_list_sp) {
1077        if (auto var_sp = ParseVariableForPDBData(sc, *pdb_data)) {
1078          local_variable_list_sp->AddVariableIfUnique(var_sp);
1079          if (variable_list)
1080            variable_list->AddVariableIfUnique(var_sp);
1081          ++num_added;
1082          PDBASTParser *ast = GetPDBAstParser();
1083          if (ast)
1084            ast->GetDeclForSymbol(*pdb_data);
1085        }
1086      }
1087    }
1088  }
1089
1090  if (auto results = pdb_symbol.findAllChildren()) {
1091    while (auto result = results->getNext())
1092      num_added += ParseVariables(sc, *result, variable_list);
1093  }
1094
1095  return num_added;
1096}
1097
1098void SymbolFilePDB::FindGlobalVariables(
1099    lldb_private::ConstString name,
1100    const lldb_private::CompilerDeclContext *parent_decl_ctx,
1101    uint32_t max_matches, lldb_private::VariableList &variables) {
1102  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1103  if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
1104    return;
1105  if (name.IsEmpty())
1106    return;
1107
1108  auto results = m_global_scope_up->findAllChildren<PDBSymbolData>();
1109  if (!results)
1110    return;
1111
1112  uint32_t matches = 0;
1113  size_t old_size = variables.GetSize();
1114  while (auto result = results->getNext()) {
1115    auto pdb_data = llvm::dyn_cast<PDBSymbolData>(result.get());
1116    if (max_matches > 0 && matches >= max_matches)
1117      break;
1118
1119    SymbolContext sc;
1120    sc.module_sp = m_objfile_sp->GetModule();
1121    lldbassert(sc.module_sp.get());
1122
1123    if (!name.GetStringRef().equals(
1124            MSVCUndecoratedNameParser::DropScope(pdb_data->getName())))
1125      continue;
1126
1127    sc.comp_unit = ParseCompileUnitForUID(GetCompilandId(*pdb_data)).get();
1128    // FIXME: We are not able to determine the compile unit.
1129    if (sc.comp_unit == nullptr)
1130      continue;
1131
1132    if (parent_decl_ctx && GetDeclContextContainingUID(
1133                               result->getSymIndexId()) != *parent_decl_ctx)
1134      continue;
1135
1136    ParseVariables(sc, *pdb_data, &variables);
1137    matches = variables.GetSize() - old_size;
1138  }
1139}
1140
1141void SymbolFilePDB::FindGlobalVariables(
1142    const lldb_private::RegularExpression &regex, uint32_t max_matches,
1143    lldb_private::VariableList &variables) {
1144  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1145  if (!regex.IsValid())
1146    return;
1147  auto results = m_global_scope_up->findAllChildren<PDBSymbolData>();
1148  if (!results)
1149    return;
1150
1151  uint32_t matches = 0;
1152  size_t old_size = variables.GetSize();
1153  while (auto pdb_data = results->getNext()) {
1154    if (max_matches > 0 && matches >= max_matches)
1155      break;
1156
1157    auto var_name = pdb_data->getName();
1158    if (var_name.empty())
1159      continue;
1160    if (!regex.Execute(var_name))
1161      continue;
1162    SymbolContext sc;
1163    sc.module_sp = m_objfile_sp->GetModule();
1164    lldbassert(sc.module_sp.get());
1165
1166    sc.comp_unit = ParseCompileUnitForUID(GetCompilandId(*pdb_data)).get();
1167    // FIXME: We are not able to determine the compile unit.
1168    if (sc.comp_unit == nullptr)
1169      continue;
1170
1171    ParseVariables(sc, *pdb_data, &variables);
1172    matches = variables.GetSize() - old_size;
1173  }
1174}
1175
1176bool SymbolFilePDB::ResolveFunction(const llvm::pdb::PDBSymbolFunc &pdb_func,
1177                                    bool include_inlines,
1178                                    lldb_private::SymbolContextList &sc_list) {
1179  lldb_private::SymbolContext sc;
1180  sc.comp_unit = ParseCompileUnitForUID(pdb_func.getCompilandId()).get();
1181  if (!sc.comp_unit)
1182    return false;
1183  sc.module_sp = sc.comp_unit->GetModule();
1184  sc.function = ParseCompileUnitFunctionForPDBFunc(pdb_func, *sc.comp_unit);
1185  if (!sc.function)
1186    return false;
1187
1188  sc_list.Append(sc);
1189  return true;
1190}
1191
1192bool SymbolFilePDB::ResolveFunction(uint32_t uid, bool include_inlines,
1193                                    lldb_private::SymbolContextList &sc_list) {
1194  auto pdb_func_up = m_session_up->getConcreteSymbolById<PDBSymbolFunc>(uid);
1195  if (!pdb_func_up && !(include_inlines && pdb_func_up->hasInlineAttribute()))
1196    return false;
1197  return ResolveFunction(*pdb_func_up, include_inlines, sc_list);
1198}
1199
1200void SymbolFilePDB::CacheFunctionNames() {
1201  if (!m_func_full_names.IsEmpty())
1202    return;
1203
1204  std::map<uint64_t, uint32_t> addr_ids;
1205
1206  if (auto results_up = m_global_scope_up->findAllChildren<PDBSymbolFunc>()) {
1207    while (auto pdb_func_up = results_up->getNext()) {
1208      if (pdb_func_up->isCompilerGenerated())
1209        continue;
1210
1211      auto name = pdb_func_up->getName();
1212      auto demangled_name = pdb_func_up->getUndecoratedName();
1213      if (name.empty() && demangled_name.empty())
1214        continue;
1215
1216      auto uid = pdb_func_up->getSymIndexId();
1217      if (!demangled_name.empty() && pdb_func_up->getVirtualAddress())
1218        addr_ids.insert(std::make_pair(pdb_func_up->getVirtualAddress(), uid));
1219
1220      if (auto parent = pdb_func_up->getClassParent()) {
1221
1222        // PDB have symbols for class/struct methods or static methods in Enum
1223        // Class. We won't bother to check if the parent is UDT or Enum here.
1224        m_func_method_names.Append(ConstString(name), uid);
1225
1226        // To search a method name, like NS::Class:MemberFunc, LLDB searches
1227        // its base name, i.e. MemberFunc by default. Since PDBSymbolFunc does
1228        // not have inforamtion of this, we extract base names and cache them
1229        // by our own effort.
1230        llvm::StringRef basename = MSVCUndecoratedNameParser::DropScope(name);
1231        if (!basename.empty())
1232          m_func_base_names.Append(ConstString(basename), uid);
1233        else {
1234          m_func_base_names.Append(ConstString(name), uid);
1235        }
1236
1237        if (!demangled_name.empty())
1238          m_func_full_names.Append(ConstString(demangled_name), uid);
1239
1240      } else {
1241        // Handle not-method symbols.
1242
1243        // The function name might contain namespace, or its lexical scope.
1244        llvm::StringRef basename = MSVCUndecoratedNameParser::DropScope(name);
1245        if (!basename.empty())
1246          m_func_base_names.Append(ConstString(basename), uid);
1247        else
1248          m_func_base_names.Append(ConstString(name), uid);
1249
1250        if (name == "main") {
1251          m_func_full_names.Append(ConstString(name), uid);
1252
1253          if (!demangled_name.empty() && name != demangled_name) {
1254            m_func_full_names.Append(ConstString(demangled_name), uid);
1255            m_func_base_names.Append(ConstString(demangled_name), uid);
1256          }
1257        } else if (!demangled_name.empty()) {
1258          m_func_full_names.Append(ConstString(demangled_name), uid);
1259        } else {
1260          m_func_full_names.Append(ConstString(name), uid);
1261        }
1262      }
1263    }
1264  }
1265
1266  if (auto results_up =
1267          m_global_scope_up->findAllChildren<PDBSymbolPublicSymbol>()) {
1268    while (auto pub_sym_up = results_up->getNext()) {
1269      if (!pub_sym_up->isFunction())
1270        continue;
1271      auto name = pub_sym_up->getName();
1272      if (name.empty())
1273        continue;
1274
1275      if (CPlusPlusLanguage::IsCPPMangledName(name.c_str())) {
1276        auto vm_addr = pub_sym_up->getVirtualAddress();
1277
1278        // PDB public symbol has mangled name for its associated function.
1279        if (vm_addr && addr_ids.find(vm_addr) != addr_ids.end()) {
1280          // Cache mangled name.
1281          m_func_full_names.Append(ConstString(name), addr_ids[vm_addr]);
1282        }
1283      }
1284    }
1285  }
1286  // Sort them before value searching is working properly
1287  m_func_full_names.Sort();
1288  m_func_full_names.SizeToFit();
1289  m_func_method_names.Sort();
1290  m_func_method_names.SizeToFit();
1291  m_func_base_names.Sort();
1292  m_func_base_names.SizeToFit();
1293}
1294
1295void SymbolFilePDB::FindFunctions(
1296    lldb_private::ConstString name,
1297    const lldb_private::CompilerDeclContext *parent_decl_ctx,
1298    FunctionNameType name_type_mask, bool include_inlines,
1299    lldb_private::SymbolContextList &sc_list) {
1300  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1301  lldbassert((name_type_mask & eFunctionNameTypeAuto) == 0);
1302
1303  if (name_type_mask == eFunctionNameTypeNone)
1304    return;
1305  if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
1306    return;
1307  if (name.IsEmpty())
1308    return;
1309
1310  if (name_type_mask & eFunctionNameTypeFull ||
1311      name_type_mask & eFunctionNameTypeBase ||
1312      name_type_mask & eFunctionNameTypeMethod) {
1313    CacheFunctionNames();
1314
1315    std::set<uint32_t> resolved_ids;
1316    auto ResolveFn = [this, &name, parent_decl_ctx, include_inlines, &sc_list,
1317                      &resolved_ids](UniqueCStringMap<uint32_t> &Names) {
1318      std::vector<uint32_t> ids;
1319      if (!Names.GetValues(name, ids))
1320        return;
1321
1322      for (uint32_t id : ids) {
1323        if (resolved_ids.find(id) != resolved_ids.end())
1324          continue;
1325
1326        if (parent_decl_ctx &&
1327            GetDeclContextContainingUID(id) != *parent_decl_ctx)
1328          continue;
1329
1330        if (ResolveFunction(id, include_inlines, sc_list))
1331          resolved_ids.insert(id);
1332      }
1333    };
1334    if (name_type_mask & eFunctionNameTypeFull) {
1335      ResolveFn(m_func_full_names);
1336      ResolveFn(m_func_base_names);
1337      ResolveFn(m_func_method_names);
1338    }
1339    if (name_type_mask & eFunctionNameTypeBase)
1340      ResolveFn(m_func_base_names);
1341    if (name_type_mask & eFunctionNameTypeMethod)
1342      ResolveFn(m_func_method_names);
1343  }
1344}
1345
1346void SymbolFilePDB::FindFunctions(const lldb_private::RegularExpression &regex,
1347                                  bool include_inlines,
1348                                  lldb_private::SymbolContextList &sc_list) {
1349  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1350  if (!regex.IsValid())
1351    return;
1352
1353  CacheFunctionNames();
1354
1355  std::set<uint32_t> resolved_ids;
1356  auto ResolveFn = [&regex, include_inlines, &sc_list, &resolved_ids,
1357                    this](UniqueCStringMap<uint32_t> &Names) {
1358    std::vector<uint32_t> ids;
1359    if (Names.GetValues(regex, ids)) {
1360      for (auto id : ids) {
1361        if (resolved_ids.find(id) == resolved_ids.end())
1362          if (ResolveFunction(id, include_inlines, sc_list))
1363            resolved_ids.insert(id);
1364      }
1365    }
1366  };
1367  ResolveFn(m_func_full_names);
1368  ResolveFn(m_func_base_names);
1369}
1370
1371void SymbolFilePDB::GetMangledNamesForFunction(
1372    const std::string &scope_qualified_name,
1373    std::vector<lldb_private::ConstString> &mangled_names) {}
1374
1375void SymbolFilePDB::AddSymbols(lldb_private::Symtab &symtab) {
1376  std::set<lldb::addr_t> sym_addresses;
1377  for (size_t i = 0; i < symtab.GetNumSymbols(); i++)
1378    sym_addresses.insert(symtab.SymbolAtIndex(i)->GetFileAddress());
1379
1380  auto results = m_global_scope_up->findAllChildren<PDBSymbolPublicSymbol>();
1381  if (!results)
1382    return;
1383
1384  auto section_list = m_objfile_sp->GetSectionList();
1385  if (!section_list)
1386    return;
1387
1388  while (auto pub_symbol = results->getNext()) {
1389    auto section_id = pub_symbol->getAddressSection();
1390
1391    auto section = section_list->FindSectionByID(section_id);
1392    if (!section)
1393      continue;
1394
1395    auto offset = pub_symbol->getAddressOffset();
1396
1397    auto file_addr = section->GetFileAddress() + offset;
1398    if (sym_addresses.find(file_addr) != sym_addresses.end())
1399      continue;
1400    sym_addresses.insert(file_addr);
1401
1402    auto size = pub_symbol->getLength();
1403    symtab.AddSymbol(
1404        Symbol(pub_symbol->getSymIndexId(),   // symID
1405               pub_symbol->getName().c_str(), // name
1406               pub_symbol->isCode() ? eSymbolTypeCode : eSymbolTypeData, // type
1407               true,      // external
1408               false,     // is_debug
1409               false,     // is_trampoline
1410               false,     // is_artificial
1411               section,   // section_sp
1412               offset,    // value
1413               size,      // size
1414               size != 0, // size_is_valid
1415               false,     // contains_linker_annotations
1416               0          // flags
1417               ));
1418  }
1419
1420  symtab.CalculateSymbolSizes();
1421  symtab.Finalize();
1422}
1423
1424void SymbolFilePDB::FindTypes(
1425    lldb_private::ConstString name,
1426    const lldb_private::CompilerDeclContext *parent_decl_ctx,
1427    uint32_t max_matches,
1428    llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
1429    lldb_private::TypeMap &types) {
1430  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1431  if (!name)
1432    return;
1433  if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
1434    return;
1435
1436  searched_symbol_files.clear();
1437  searched_symbol_files.insert(this);
1438
1439  // There is an assumption 'name' is not a regex
1440  FindTypesByName(name.GetStringRef(), parent_decl_ctx, max_matches, types);
1441}
1442
1443void SymbolFilePDB::DumpClangAST(Stream &s) {
1444  auto type_system_or_err =
1445      GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
1446  if (auto err = type_system_or_err.takeError()) {
1447    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
1448                   std::move(err), "Unable to dump ClangAST");
1449    return;
1450  }
1451
1452  auto *clang_type_system =
1453      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
1454  if (!clang_type_system)
1455    return;
1456  clang_type_system->Dump(s);
1457}
1458
1459void SymbolFilePDB::FindTypesByRegex(
1460    const lldb_private::RegularExpression &regex, uint32_t max_matches,
1461    lldb_private::TypeMap &types) {
1462  // When searching by regex, we need to go out of our way to limit the search
1463  // space as much as possible since this searches EVERYTHING in the PDB,
1464  // manually doing regex comparisons.  PDB library isn't optimized for regex
1465  // searches or searches across multiple symbol types at the same time, so the
1466  // best we can do is to search enums, then typedefs, then classes one by one,
1467  // and do a regex comparison against each of them.
1468  PDB_SymType tags_to_search[] = {PDB_SymType::Enum, PDB_SymType::Typedef,
1469                                  PDB_SymType::UDT};
1470  std::unique_ptr<IPDBEnumSymbols> results;
1471
1472  uint32_t matches = 0;
1473
1474  for (auto tag : tags_to_search) {
1475    results = m_global_scope_up->findAllChildren(tag);
1476    if (!results)
1477      continue;
1478
1479    while (auto result = results->getNext()) {
1480      if (max_matches > 0 && matches >= max_matches)
1481        break;
1482
1483      std::string type_name;
1484      if (auto enum_type = llvm::dyn_cast<PDBSymbolTypeEnum>(result.get()))
1485        type_name = enum_type->getName();
1486      else if (auto typedef_type =
1487                   llvm::dyn_cast<PDBSymbolTypeTypedef>(result.get()))
1488        type_name = typedef_type->getName();
1489      else if (auto class_type = llvm::dyn_cast<PDBSymbolTypeUDT>(result.get()))
1490        type_name = class_type->getName();
1491      else {
1492        // We're looking only for types that have names.  Skip symbols, as well
1493        // as unnamed types such as arrays, pointers, etc.
1494        continue;
1495      }
1496
1497      if (!regex.Execute(type_name))
1498        continue;
1499
1500      // This should cause the type to get cached and stored in the `m_types`
1501      // lookup.
1502      if (!ResolveTypeUID(result->getSymIndexId()))
1503        continue;
1504
1505      auto iter = m_types.find(result->getSymIndexId());
1506      if (iter == m_types.end())
1507        continue;
1508      types.Insert(iter->second);
1509      ++matches;
1510    }
1511  }
1512}
1513
1514void SymbolFilePDB::FindTypesByName(
1515    llvm::StringRef name,
1516    const lldb_private::CompilerDeclContext *parent_decl_ctx,
1517    uint32_t max_matches, lldb_private::TypeMap &types) {
1518  std::unique_ptr<IPDBEnumSymbols> results;
1519  if (name.empty())
1520    return;
1521  results = m_global_scope_up->findAllChildren(PDB_SymType::None);
1522  if (!results)
1523    return;
1524
1525  uint32_t matches = 0;
1526
1527  while (auto result = results->getNext()) {
1528    if (max_matches > 0 && matches >= max_matches)
1529      break;
1530
1531    if (MSVCUndecoratedNameParser::DropScope(
1532            result->getRawSymbol().getName()) != name)
1533      continue;
1534
1535    switch (result->getSymTag()) {
1536    case PDB_SymType::Enum:
1537    case PDB_SymType::UDT:
1538    case PDB_SymType::Typedef:
1539      break;
1540    default:
1541      // We're looking only for types that have names.  Skip symbols, as well
1542      // as unnamed types such as arrays, pointers, etc.
1543      continue;
1544    }
1545
1546    // This should cause the type to get cached and stored in the `m_types`
1547    // lookup.
1548    if (!ResolveTypeUID(result->getSymIndexId()))
1549      continue;
1550
1551    if (parent_decl_ctx && GetDeclContextContainingUID(
1552                               result->getSymIndexId()) != *parent_decl_ctx)
1553      continue;
1554
1555    auto iter = m_types.find(result->getSymIndexId());
1556    if (iter == m_types.end())
1557      continue;
1558    types.Insert(iter->second);
1559    ++matches;
1560  }
1561}
1562
1563void SymbolFilePDB::FindTypes(
1564    llvm::ArrayRef<CompilerContext> pattern, LanguageSet languages,
1565    llvm::DenseSet<SymbolFile *> &searched_symbol_files,
1566    lldb_private::TypeMap &types) {}
1567
1568void SymbolFilePDB::GetTypesForPDBSymbol(const llvm::pdb::PDBSymbol &pdb_symbol,
1569                                         uint32_t type_mask,
1570                                         TypeCollection &type_collection) {
1571  bool can_parse = false;
1572  switch (pdb_symbol.getSymTag()) {
1573  case PDB_SymType::ArrayType:
1574    can_parse = ((type_mask & eTypeClassArray) != 0);
1575    break;
1576  case PDB_SymType::BuiltinType:
1577    can_parse = ((type_mask & eTypeClassBuiltin) != 0);
1578    break;
1579  case PDB_SymType::Enum:
1580    can_parse = ((type_mask & eTypeClassEnumeration) != 0);
1581    break;
1582  case PDB_SymType::Function:
1583  case PDB_SymType::FunctionSig:
1584    can_parse = ((type_mask & eTypeClassFunction) != 0);
1585    break;
1586  case PDB_SymType::PointerType:
1587    can_parse = ((type_mask & (eTypeClassPointer | eTypeClassBlockPointer |
1588                               eTypeClassMemberPointer)) != 0);
1589    break;
1590  case PDB_SymType::Typedef:
1591    can_parse = ((type_mask & eTypeClassTypedef) != 0);
1592    break;
1593  case PDB_SymType::UDT: {
1594    auto *udt = llvm::dyn_cast<PDBSymbolTypeUDT>(&pdb_symbol);
1595    assert(udt);
1596    can_parse = (udt->getUdtKind() != PDB_UdtType::Interface &&
1597                 ((type_mask & (eTypeClassClass | eTypeClassStruct |
1598                                eTypeClassUnion)) != 0));
1599  } break;
1600  default:
1601    break;
1602  }
1603
1604  if (can_parse) {
1605    if (auto *type = ResolveTypeUID(pdb_symbol.getSymIndexId())) {
1606      auto result =
1607          std::find(type_collection.begin(), type_collection.end(), type);
1608      if (result == type_collection.end())
1609        type_collection.push_back(type);
1610    }
1611  }
1612
1613  auto results_up = pdb_symbol.findAllChildren();
1614  while (auto symbol_up = results_up->getNext())
1615    GetTypesForPDBSymbol(*symbol_up, type_mask, type_collection);
1616}
1617
1618void SymbolFilePDB::GetTypes(lldb_private::SymbolContextScope *sc_scope,
1619                             TypeClass type_mask,
1620                             lldb_private::TypeList &type_list) {
1621  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1622  TypeCollection type_collection;
1623  CompileUnit *cu =
1624      sc_scope ? sc_scope->CalculateSymbolContextCompileUnit() : nullptr;
1625  if (cu) {
1626    auto compiland_up = GetPDBCompilandByUID(cu->GetID());
1627    if (!compiland_up)
1628      return;
1629    GetTypesForPDBSymbol(*compiland_up, type_mask, type_collection);
1630  } else {
1631    for (uint32_t cu_idx = 0; cu_idx < GetNumCompileUnits(); ++cu_idx) {
1632      auto cu_sp = ParseCompileUnitAtIndex(cu_idx);
1633      if (cu_sp) {
1634        if (auto compiland_up = GetPDBCompilandByUID(cu_sp->GetID()))
1635          GetTypesForPDBSymbol(*compiland_up, type_mask, type_collection);
1636      }
1637    }
1638  }
1639
1640  for (auto type : type_collection) {
1641    type->GetForwardCompilerType();
1642    type_list.Insert(type->shared_from_this());
1643  }
1644}
1645
1646llvm::Expected<lldb_private::TypeSystem &>
1647SymbolFilePDB::GetTypeSystemForLanguage(lldb::LanguageType language) {
1648  auto type_system_or_err =
1649      m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
1650  if (type_system_or_err) {
1651    type_system_or_err->SetSymbolFile(this);
1652  }
1653  return type_system_or_err;
1654}
1655
1656PDBASTParser *SymbolFilePDB::GetPDBAstParser() {
1657  auto type_system_or_err =
1658      GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
1659  if (auto err = type_system_or_err.takeError()) {
1660    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
1661                   std::move(err), "Unable to get PDB AST parser");
1662    return nullptr;
1663  }
1664
1665  auto *clang_type_system =
1666      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
1667  if (!clang_type_system)
1668    return nullptr;
1669
1670  return clang_type_system->GetPDBParser();
1671}
1672
1673
1674lldb_private::CompilerDeclContext SymbolFilePDB::FindNamespace(
1675    lldb_private::ConstString name,
1676    const lldb_private::CompilerDeclContext *parent_decl_ctx) {
1677  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1678  auto type_system_or_err =
1679      GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
1680  if (auto err = type_system_or_err.takeError()) {
1681    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
1682                   std::move(err), "Unable to find namespace {}",
1683                   name.AsCString());
1684    return CompilerDeclContext();
1685  }
1686
1687  auto *clang_type_system =
1688      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
1689  if (!clang_type_system)
1690    return CompilerDeclContext();
1691
1692  PDBASTParser *pdb = clang_type_system->GetPDBParser();
1693  if (!pdb)
1694    return CompilerDeclContext();
1695
1696  clang::DeclContext *decl_context = nullptr;
1697  if (parent_decl_ctx)
1698    decl_context = static_cast<clang::DeclContext *>(
1699        parent_decl_ctx->GetOpaqueDeclContext());
1700
1701  auto namespace_decl =
1702      pdb->FindNamespaceDecl(decl_context, name.GetStringRef());
1703  if (!namespace_decl)
1704    return CompilerDeclContext();
1705
1706  return clang_type_system->CreateDeclContext(namespace_decl);
1707}
1708
1709lldb_private::ConstString SymbolFilePDB::GetPluginName() {
1710  static ConstString g_name("pdb");
1711  return g_name;
1712}
1713
1714uint32_t SymbolFilePDB::GetPluginVersion() { return 1; }
1715
1716IPDBSession &SymbolFilePDB::GetPDBSession() { return *m_session_up; }
1717
1718const IPDBSession &SymbolFilePDB::GetPDBSession() const {
1719  return *m_session_up;
1720}
1721
1722lldb::CompUnitSP SymbolFilePDB::ParseCompileUnitForUID(uint32_t id,
1723                                                       uint32_t index) {
1724  auto found_cu = m_comp_units.find(id);
1725  if (found_cu != m_comp_units.end())
1726    return found_cu->second;
1727
1728  auto compiland_up = GetPDBCompilandByUID(id);
1729  if (!compiland_up)
1730    return CompUnitSP();
1731
1732  lldb::LanguageType lang;
1733  auto details = compiland_up->findOneChild<PDBSymbolCompilandDetails>();
1734  if (!details)
1735    lang = lldb::eLanguageTypeC_plus_plus;
1736  else
1737    lang = TranslateLanguage(details->getLanguage());
1738
1739  if (lang == lldb::LanguageType::eLanguageTypeUnknown)
1740    return CompUnitSP();
1741
1742  std::string path = compiland_up->getSourceFileFullPath();
1743  if (path.empty())
1744    return CompUnitSP();
1745
1746  // Don't support optimized code for now, DebugInfoPDB does not return this
1747  // information.
1748  LazyBool optimized = eLazyBoolNo;
1749  auto cu_sp = std::make_shared<CompileUnit>(m_objfile_sp->GetModule(), nullptr,
1750                                             path.c_str(), id, lang, optimized);
1751
1752  if (!cu_sp)
1753    return CompUnitSP();
1754
1755  m_comp_units.insert(std::make_pair(id, cu_sp));
1756  if (index == UINT32_MAX)
1757    GetCompileUnitIndex(*compiland_up, index);
1758  lldbassert(index != UINT32_MAX);
1759  SetCompileUnitAtIndex(index, cu_sp);
1760  return cu_sp;
1761}
1762
1763bool SymbolFilePDB::ParseCompileUnitLineTable(CompileUnit &comp_unit,
1764                                              uint32_t match_line) {
1765  auto compiland_up = GetPDBCompilandByUID(comp_unit.GetID());
1766  if (!compiland_up)
1767    return false;
1768
1769  // LineEntry needs the *index* of the file into the list of support files
1770  // returned by ParseCompileUnitSupportFiles.  But the underlying SDK gives us
1771  // a globally unique idenfitifier in the namespace of the PDB.  So, we have
1772  // to do a mapping so that we can hand out indices.
1773  llvm::DenseMap<uint32_t, uint32_t> index_map;
1774  BuildSupportFileIdToSupportFileIndexMap(*compiland_up, index_map);
1775  auto line_table = std::make_unique<LineTable>(&comp_unit);
1776
1777  // Find contributions to `compiland` from all source and header files.
1778  auto files = m_session_up->getSourceFilesForCompiland(*compiland_up);
1779  if (!files)
1780    return false;
1781
1782  // For each source and header file, create a LineSequence for contributions
1783  // to the compiland from that file, and add the sequence.
1784  while (auto file = files->getNext()) {
1785    std::unique_ptr<LineSequence> sequence(
1786        line_table->CreateLineSequenceContainer());
1787    auto lines = m_session_up->findLineNumbers(*compiland_up, *file);
1788    if (!lines)
1789      continue;
1790    int entry_count = lines->getChildCount();
1791
1792    uint64_t prev_addr;
1793    uint32_t prev_length;
1794    uint32_t prev_line;
1795    uint32_t prev_source_idx;
1796
1797    for (int i = 0; i < entry_count; ++i) {
1798      auto line = lines->getChildAtIndex(i);
1799
1800      uint64_t lno = line->getLineNumber();
1801      uint64_t addr = line->getVirtualAddress();
1802      uint32_t length = line->getLength();
1803      uint32_t source_id = line->getSourceFileId();
1804      uint32_t col = line->getColumnNumber();
1805      uint32_t source_idx = index_map[source_id];
1806
1807      // There was a gap between the current entry and the previous entry if
1808      // the addresses don't perfectly line up.
1809      bool is_gap = (i > 0) && (prev_addr + prev_length < addr);
1810
1811      // Before inserting the current entry, insert a terminal entry at the end
1812      // of the previous entry's address range if the current entry resulted in
1813      // a gap from the previous entry.
1814      if (is_gap && ShouldAddLine(match_line, prev_line, prev_length)) {
1815        line_table->AppendLineEntryToSequence(
1816            sequence.get(), prev_addr + prev_length, prev_line, 0,
1817            prev_source_idx, false, false, false, false, true);
1818
1819        line_table->InsertSequence(sequence.release());
1820        sequence.reset(line_table->CreateLineSequenceContainer());
1821      }
1822
1823      if (ShouldAddLine(match_line, lno, length)) {
1824        bool is_statement = line->isStatement();
1825        bool is_prologue = false;
1826        bool is_epilogue = false;
1827        auto func =
1828            m_session_up->findSymbolByAddress(addr, PDB_SymType::Function);
1829        if (func) {
1830          auto prologue = func->findOneChild<PDBSymbolFuncDebugStart>();
1831          if (prologue)
1832            is_prologue = (addr == prologue->getVirtualAddress());
1833
1834          auto epilogue = func->findOneChild<PDBSymbolFuncDebugEnd>();
1835          if (epilogue)
1836            is_epilogue = (addr == epilogue->getVirtualAddress());
1837        }
1838
1839        line_table->AppendLineEntryToSequence(sequence.get(), addr, lno, col,
1840                                              source_idx, is_statement, false,
1841                                              is_prologue, is_epilogue, false);
1842      }
1843
1844      prev_addr = addr;
1845      prev_length = length;
1846      prev_line = lno;
1847      prev_source_idx = source_idx;
1848    }
1849
1850    if (entry_count > 0 && ShouldAddLine(match_line, prev_line, prev_length)) {
1851      // The end is always a terminal entry, so insert it regardless.
1852      line_table->AppendLineEntryToSequence(
1853          sequence.get(), prev_addr + prev_length, prev_line, 0,
1854          prev_source_idx, false, false, false, false, true);
1855    }
1856
1857    line_table->InsertSequence(sequence.release());
1858  }
1859
1860  if (line_table->GetSize()) {
1861    comp_unit.SetLineTable(line_table.release());
1862    return true;
1863  }
1864  return false;
1865}
1866
1867void SymbolFilePDB::BuildSupportFileIdToSupportFileIndexMap(
1868    const PDBSymbolCompiland &compiland,
1869    llvm::DenseMap<uint32_t, uint32_t> &index_map) const {
1870  // This is a hack, but we need to convert the source id into an index into
1871  // the support files array.  We don't want to do path comparisons to avoid
1872  // basename / full path issues that may or may not even be a problem, so we
1873  // use the globally unique source file identifiers.  Ideally we could use the
1874  // global identifiers everywhere, but LineEntry currently assumes indices.
1875  auto source_files = m_session_up->getSourceFilesForCompiland(compiland);
1876  if (!source_files)
1877    return;
1878
1879  int index = 0;
1880  while (auto file = source_files->getNext()) {
1881    uint32_t source_id = file->getUniqueId();
1882    index_map[source_id] = index++;
1883  }
1884}
1885
1886lldb::CompUnitSP SymbolFilePDB::GetCompileUnitContainsAddress(
1887    const lldb_private::Address &so_addr) {
1888  lldb::addr_t file_vm_addr = so_addr.GetFileAddress();
1889  if (file_vm_addr == LLDB_INVALID_ADDRESS || file_vm_addr == 0)
1890    return nullptr;
1891
1892  // If it is a PDB function's vm addr, this is the first sure bet.
1893  if (auto lines =
1894          m_session_up->findLineNumbersByAddress(file_vm_addr, /*Length=*/1)) {
1895    if (auto first_line = lines->getNext())
1896      return ParseCompileUnitForUID(first_line->getCompilandId());
1897  }
1898
1899  // Otherwise we resort to section contributions.
1900  if (auto sec_contribs = m_session_up->getSectionContribs()) {
1901    while (auto section = sec_contribs->getNext()) {
1902      auto va = section->getVirtualAddress();
1903      if (file_vm_addr >= va && file_vm_addr < va + section->getLength())
1904        return ParseCompileUnitForUID(section->getCompilandId());
1905    }
1906  }
1907  return nullptr;
1908}
1909
1910Mangled
1911SymbolFilePDB::GetMangledForPDBFunc(const llvm::pdb::PDBSymbolFunc &pdb_func) {
1912  Mangled mangled;
1913  auto func_name = pdb_func.getName();
1914  auto func_undecorated_name = pdb_func.getUndecoratedName();
1915  std::string func_decorated_name;
1916
1917  // Seek from public symbols for non-static function's decorated name if any.
1918  // For static functions, they don't have undecorated names and aren't exposed
1919  // in Public Symbols either.
1920  if (!func_undecorated_name.empty()) {
1921    auto result_up = m_global_scope_up->findChildren(
1922        PDB_SymType::PublicSymbol, func_undecorated_name,
1923        PDB_NameSearchFlags::NS_UndecoratedName);
1924    if (result_up) {
1925      while (auto symbol_up = result_up->getNext()) {
1926        // For a public symbol, it is unique.
1927        lldbassert(result_up->getChildCount() == 1);
1928        if (auto *pdb_public_sym =
1929                llvm::dyn_cast_or_null<PDBSymbolPublicSymbol>(
1930                    symbol_up.get())) {
1931          if (pdb_public_sym->isFunction()) {
1932            func_decorated_name = pdb_public_sym->getName();
1933            break;
1934          }
1935        }
1936      }
1937    }
1938  }
1939  if (!func_decorated_name.empty()) {
1940    mangled.SetMangledName(ConstString(func_decorated_name));
1941
1942    // For MSVC, format of C funciton's decorated name depends on calling
1943    // conventon. Unfortunately none of the format is recognized by current
1944    // LLDB. For example, `_purecall` is a __cdecl C function. From PDB,
1945    // `__purecall` is retrieved as both its decorated and undecorated name
1946    // (using PDBSymbolFunc::getUndecoratedName method). However `__purecall`
1947    // string is not treated as mangled in LLDB (neither `?` nor `_Z` prefix).
1948    // Mangled::GetDemangledName method will fail internally and caches an
1949    // empty string as its undecorated name. So we will face a contradition
1950    // here for the same symbol:
1951    //   non-empty undecorated name from PDB
1952    //   empty undecorated name from LLDB
1953    if (!func_undecorated_name.empty() &&
1954        mangled.GetDemangledName(mangled.GuessLanguage()).IsEmpty())
1955      mangled.SetDemangledName(ConstString(func_undecorated_name));
1956
1957    // LLDB uses several flags to control how a C++ decorated name is
1958    // undecorated for MSVC. See `safeUndecorateName` in Class Mangled. So the
1959    // yielded name could be different from what we retrieve from
1960    // PDB source unless we also apply same flags in getting undecorated
1961    // name through PDBSymbolFunc::getUndecoratedNameEx method.
1962    if (!func_undecorated_name.empty() &&
1963        mangled.GetDemangledName(mangled.GuessLanguage()) !=
1964            ConstString(func_undecorated_name))
1965      mangled.SetDemangledName(ConstString(func_undecorated_name));
1966  } else if (!func_undecorated_name.empty()) {
1967    mangled.SetDemangledName(ConstString(func_undecorated_name));
1968  } else if (!func_name.empty())
1969    mangled.SetValue(ConstString(func_name), false);
1970
1971  return mangled;
1972}
1973
1974bool SymbolFilePDB::DeclContextMatchesThisSymbolFile(
1975    const lldb_private::CompilerDeclContext *decl_ctx) {
1976  if (decl_ctx == nullptr || !decl_ctx->IsValid())
1977    return true;
1978
1979  TypeSystem *decl_ctx_type_system = decl_ctx->GetTypeSystem();
1980  if (!decl_ctx_type_system)
1981    return false;
1982  auto type_system_or_err = GetTypeSystemForLanguage(
1983      decl_ctx_type_system->GetMinimumLanguage(nullptr));
1984  if (auto err = type_system_or_err.takeError()) {
1985    LLDB_LOG_ERROR(
1986        lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
1987        std::move(err),
1988        "Unable to determine if DeclContext matches this symbol file");
1989    return false;
1990  }
1991
1992  if (decl_ctx_type_system == &type_system_or_err.get())
1993    return true; // The type systems match, return true
1994
1995  return false;
1996}
1997
1998uint32_t SymbolFilePDB::GetCompilandId(const llvm::pdb::PDBSymbolData &data) {
1999  static const auto pred_upper = [](uint32_t lhs, SecContribInfo rhs) {
2000    return lhs < rhs.Offset;
2001  };
2002
2003  // Cache section contributions
2004  if (m_sec_contribs.empty()) {
2005    if (auto SecContribs = m_session_up->getSectionContribs()) {
2006      while (auto SectionContrib = SecContribs->getNext()) {
2007        auto comp_id = SectionContrib->getCompilandId();
2008        if (!comp_id)
2009          continue;
2010
2011        auto sec = SectionContrib->getAddressSection();
2012        auto &sec_cs = m_sec_contribs[sec];
2013
2014        auto offset = SectionContrib->getAddressOffset();
2015        auto it =
2016            std::upper_bound(sec_cs.begin(), sec_cs.end(), offset, pred_upper);
2017
2018        auto size = SectionContrib->getLength();
2019        sec_cs.insert(it, {offset, size, comp_id});
2020      }
2021    }
2022  }
2023
2024  // Check by line number
2025  if (auto Lines = data.getLineNumbers()) {
2026    if (auto FirstLine = Lines->getNext())
2027      return FirstLine->getCompilandId();
2028  }
2029
2030  // Retrieve section + offset
2031  uint32_t DataSection = data.getAddressSection();
2032  uint32_t DataOffset = data.getAddressOffset();
2033  if (DataSection == 0) {
2034    if (auto RVA = data.getRelativeVirtualAddress())
2035      m_session_up->addressForRVA(RVA, DataSection, DataOffset);
2036  }
2037
2038  if (DataSection) {
2039    // Search by section contributions
2040    auto &sec_cs = m_sec_contribs[DataSection];
2041    auto it =
2042        std::upper_bound(sec_cs.begin(), sec_cs.end(), DataOffset, pred_upper);
2043    if (it != sec_cs.begin()) {
2044      --it;
2045      if (DataOffset < it->Offset + it->Size)
2046        return it->CompilandId;
2047    }
2048  } else {
2049    // Search in lexical tree
2050    auto LexParentId = data.getLexicalParentId();
2051    while (auto LexParent = m_session_up->getSymbolById(LexParentId)) {
2052      if (LexParent->getSymTag() == PDB_SymType::Exe)
2053        break;
2054      if (LexParent->getSymTag() == PDB_SymType::Compiland)
2055        return LexParentId;
2056      LexParentId = LexParent->getRawSymbol().getLexicalParentId();
2057    }
2058  }
2059
2060  return 0;
2061}
2062