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