[lldb] Add support to cache a PDB's global scope and fix a bug in getting the source file name for a compiland

[asmith]

Summary

This commit is a combination of the following changes:

• Cache PDB's global scope (executable) in SymbolFilePDB

• Change naming of cu to compiland which is PDB specific

• Change ParseCompileUnitForSymIndex to ParseCompileUnitForUID. Prefer using a common name UID instead of PDB's System Index Adding one more argument index to this method, which is used to specify the index of the compile unit in a cached compile unit array

• Add GetPDBCompilandByUID method to simply code

• Fix a bug in getting the source file name for a PDB compiland. For some reason, PDBSymbolCompiland::getSourceFileName() could return an empty name, so if that is true, we have to walk through all source files of this compiland and determine the right source file used to generate this compiland based on language indicated.
  
  The previous implementation called PDBSession::findOneSourceFile method to get its name for the compiland. This is not accurate since the one source file found could be a header other than source file.

[zturner]

Since it seems like you're going to be doing some work in here, it would be great if you could update lldb-test to dump PDB symbol information. This would allow us to easily test all sorts of things in here. For example, you could find a PDB that returned an empty source file name, and then have the tool dump something like:

Compiland: {foo}, Source File: {bar}

then we could just grep this output against FileCheck.

source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

367–370

Is it DIA that is returning the empty name?

371

Can you do an early return here?

382–389

This would probably be shorter as:

llvm::is_contained({"cpp", "c", "cc", "cxx"}, file_extension.GetStringRef().lower());

683

Early return here.

763

nit: .get() shouldn't be necessary

767

Same here.

source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

197

Is this a performance win or just a convenience? I assumed the session itself would cache the global scope, but maybe that assumption was wrong.

[asmith]

These changes will fix this crash in the current mainline:

lldb-test.exe symbols (path-to-your-lldb-exe)

[zturner]

Can you add a test with REQUIRES: windows that builds a simple program using clang-cl, generates a PDB, and then uses lldb-test to check part of the output against that executable? It can be a one line check, basically just proving that it doesn't crash, and we can add more specific tests for certain types of symbols and types later.

[asmith]

Added a lit unit test

[zturner]

It's nice that this turned out so easy. Didn't even require modifying lldb-test.

lit/SymbolFile/PDB/compilands.test

9 ↗

(On Diff #129747)

If there's only one line then CHECK-DAG is equivalent to CHECK.

[asmith]

Cleaned up some comments before commit

source/Plugins/SymbolFile/PDB/PDBASTParser.cpp

return std::make_shared<lldb_private::Type>(
         ast_enum, lldb_private::Type::eResolveStateFull);
   } else if (auto type_def = llvm::dyn_cast<PDBSymbolTypeTypedef>(&type)) {
     lldb_private::Type *target_type =
         m_ast.GetSymbolFile()->ResolveTypeUID(type_def->getTypeId());
     if (!target_type)
       return nullptr;
     std::string name = type_def->getName();
     uint64_t bytes = type_def->getLength();
-    if (!target_type)
-      return nullptr;
     CompilerType target_ast_type = target_type->GetFullCompilerType();
     CompilerDeclContext target_decl_ctx =
         m_ast.GetSymbolFile()->GetDeclContextForUID(target_type->GetID());
     CompilerType ast_typedef =
         m_ast.CreateTypedefType(target_ast_type, name.c_str(), target_decl_ctx);
     return std::make_shared<lldb_private::Type>(
         type_def->getSymIndexId(), m_ast.GetSymbolFile(), ConstString(name),
         bytes, nullptr, target_type->GetID(),

source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

 #define lldb_Plugins_SymbolFile_PDB_SymbolFilePDB_h_
 
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Utility/UserID.h"
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/DebugInfo/PDB/IPDBSession.h"
 #include "llvm/DebugInfo/PDB/PDB.h"
+#include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
 
 class SymbolFilePDB : public lldb_private::SymbolFile {
 public:
   //------------------------------------------------------------------
   // Static Functions
   //------------------------------------------------------------------
   static void Initialize();
 
public:
 
   uint32_t GetPluginVersion() override;
 
   llvm::pdb::IPDBSession &GetPDBSession();
 
   const llvm::pdb::IPDBSession &GetPDBSession() const;
 
 private:
-  lldb::CompUnitSP ParseCompileUnitForSymIndex(uint32_t id);
+  lldb::CompUnitSP
+  ParseCompileUnitForUID(uint32_t id, uint32_t index = UINT32_MAX);
 
   bool ParseCompileUnitLineTable(const lldb_private::SymbolContext &sc,
                                  uint32_t match_line);
 
   void BuildSupportFileIdToSupportFileIndexMap(
-      const llvm::pdb::PDBSymbolCompiland &cu,
+      const llvm::pdb::PDBSymbolCompiland &pdb_compiland,
       llvm::DenseMap<uint32_t, uint32_t> &index_map) const;
 
   void FindTypesByRegex(const lldb_private::RegularExpression &regex,
                         uint32_t max_matches,
                         lldb_private::TypeMap &types);
 
   void FindTypesByName(const std::string &name, uint32_t max_matches,
                        lldb_private::TypeMap &types);
 
+  void GetCompileUnitIndex(const llvm::pdb::PDBSymbolCompiland *pdb_compiland,
+                           uint32_t &index);
+
+  std::string GetSourceFileNameForPDBCompiland(
+      const llvm::pdb::PDBSymbolCompiland *pdb_compiland);
+
+  std::unique_ptr<llvm::pdb::PDBSymbolCompiland>
+  GetPDBCompilandByUID(uint32_t uid);
+
   llvm::DenseMap<uint32_t, lldb::CompUnitSP> m_comp_units;
   llvm::DenseMap<uint32_t, lldb::TypeSP> m_types;
 
   std::vector<lldb::TypeSP> m_builtin_types;
   std::unique_ptr<llvm::pdb::IPDBSession> m_session_up;
+  std::unique_ptr<llvm::pdb::PDBSymbolExe> m_global_scope_up;
   uint32_t m_cached_compile_unit_count;
   std::unique_ptr<lldb_private::CompilerDeclContext> m_tu_decl_ctx_up;
 };
 
 #endif // lldb_Plugins_SymbolFile_PDB_SymbolFilePDB_h_

source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/TypeMap.h"
 #include "lldb/Utility/RegularExpression.h"
 
 #include "llvm/DebugInfo/PDB/GenericError.h"
 #include "llvm/DebugInfo/PDB/IPDBDataStream.h"
 #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
 #include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
 #include "llvm/DebugInfo/PDB/IPDBSourceFile.h"

 #include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeTypedef.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h"
 
 #include "Plugins/SymbolFile/PDB/PDBASTParser.h"
 
 #include <regex>
 
+using namespace lldb;
 using namespace lldb_private;
 using namespace llvm::pdb;
 
 namespace {
 lldb::LanguageType TranslateLanguage(PDB_Lang lang) {
   switch (lang) {
   case PDB_Lang::Cpp:
     return lldb::LanguageType::eLanguageTypeC_plus_plus;

 }
 
 lldb_private::SymbolFile *
 SymbolFilePDB::CreateInstance(lldb_private::ObjectFile *obj_file) {
   return new SymbolFilePDB(obj_file);
 }
 
 SymbolFilePDB::SymbolFilePDB(lldb_private::ObjectFile *object_file)
-    : SymbolFile(object_file), m_cached_compile_unit_count(0) {}
+    : SymbolFile(object_file), m_session_up(), m_global_scope_up(),
+      m_cached_compile_unit_count(0), m_tu_decl_ctx_up() {}
 
 SymbolFilePDB::~SymbolFilePDB() {}
 
 uint32_t SymbolFilePDB::CalculateAbilities() {
   uint32_t abilities = 0;
   if (!m_obj_file)
     return 0;
 
while (auto table_up = enum_tables_up->getNext()) {
     default: break;
     }
   }
   return abilities;
 }
 
 void SymbolFilePDB::InitializeObject() {
   lldb::addr_t obj_load_address = m_obj_file->GetFileOffset();
+  lldbassert(obj_load_address &&
+             obj_load_address != LLDB_INVALID_ADDRESS);
   m_session_up->setLoadAddress(obj_load_address);
+  if (!m_global_scope_up)
+    m_global_scope_up = m_session_up->getGlobalScope();
+  lldbassert(m_global_scope_up.get());
 
   TypeSystem *type_system =
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   ClangASTContext *clang_type_system =
       llvm::dyn_cast_or_null<ClangASTContext>(type_system);
+  lldbassert(clang_type_system);
   m_tu_decl_ctx_up = llvm::make_unique<CompilerDeclContext>(
       type_system, clang_type_system->GetTranslationUnitDecl());
 }
 
 uint32_t SymbolFilePDB::GetNumCompileUnits() {
   if (m_cached_compile_unit_count == 0) {
-    auto global = m_session_up->getGlobalScope();
-    auto compilands = global->findAllChildren<PDBSymbolCompiland>();
+    auto compilands = m_global_scope_up->findAllChildren<PDBSymbolCompiland>();
+    if (!compilands)
+      return 0;
+
+    // The linker could link *.dll (compiland language = LINK), or import
+    // *.dll. For example, a compiland with name `Import:KERNEL32.dll`
+    // could be found as a child of the global scope (PDB executable).
+    // Usually, such compilands contain `thunk` symbols in which we are not
+    // interested for now. However we still count them in the compiland list
+    // so making access to them by index could be more easier.
+    // The other reason is that if we perform any compiland related activity,
+    // like finding symbols through llvm::pdb::IPDBSession methods,
+    // such compilands will be all searched automatically no matter whether
+    // we count them in or not.
     m_cached_compile_unit_count = compilands->getChildCount();
 
     // The linker can inject an additional "dummy" compilation unit into the
     // PDB. Ignore this special compile unit for our purposes, if it is there.
     // It is always the last one.
-    auto last_cu = compilands->getChildAtIndex(m_cached_compile_unit_count - 1);
-    std::string name = last_cu->getName();
+    auto last_compiland_up =
+        compilands->getChildAtIndex(m_cached_compile_unit_count - 1);
+    lldbassert(last_compiland_up.get());
+    std::string name = last_compiland_up->getName();
     if (name == "* Linker *")
       --m_cached_compile_unit_count;
   }
   return m_cached_compile_unit_count;
 }
 
-lldb::CompUnitSP SymbolFilePDB::ParseCompileUnitAtIndex(uint32_t index) {
-  auto global = m_session_up->getGlobalScope();
-  auto compilands = global->findAllChildren<PDBSymbolCompiland>();
-  auto cu = compilands->getChildAtIndex(index);
+void SymbolFilePDB::GetCompileUnitIndex(
+    const llvm::pdb::PDBSymbolCompiland *pdb_compiland,
+    uint32_t &index) {
+  if (!pdb_compiland)
+    return;
+
+  auto results_up = m_global_scope_up->findAllChildren<PDBSymbolCompiland>();
+  if (!results_up)
+    return;
+  auto uid = pdb_compiland->getSymIndexId();
+  for (int cu_idx = 0; cu_idx < GetNumCompileUnits(); ++cu_idx) {
+    auto compiland_up = results_up->getChildAtIndex(cu_idx);
+    if (!compiland_up)
+      continue;
+    if (compiland_up->getSymIndexId() == uid) {
+      index = cu_idx;
+      return;
+    }
+  }
+  index = UINT32_MAX;
+  return;
+}
 
-  uint32_t id = cu->getSymIndexId();
+std::unique_ptr<llvm::pdb::PDBSymbolCompiland>
+SymbolFilePDB::GetPDBCompilandByUID(uint32_t uid) {
+  return m_session_up->getConcreteSymbolById<PDBSymbolCompiland>(uid);
+}
 
-  return ParseCompileUnitForSymIndex(id);
+lldb::CompUnitSP SymbolFilePDB::ParseCompileUnitAtIndex(uint32_t index) {
+  if (index >= GetNumCompileUnits())
+    return CompUnitSP();
+
+  // Assuming we always retrieve same compilands listed in same order through
+  // `PDBSymbolExe::findAllChildren` method, Otherwise using `index` to get a
+  // compile unit makes no sense. Or we have to cache them.
+  auto results = m_global_scope_up->findAllChildren<PDBSymbolCompiland>();
+  if (!results)
+    return CompUnitSP();
+  auto compiland_up = results->getChildAtIndex(index);
+  if (!compiland_up)
+    return CompUnitSP();
+  return ParseCompileUnitForUID(compiland_up->getSymIndexId(), index);
 }
 
 lldb::LanguageType
 SymbolFilePDB::ParseCompileUnitLanguage(const lldb_private::SymbolContext &sc) {
   // What fields should I expect to be filled out on the SymbolContext?  Is it
   // safe to assume that `sc.comp_unit` is valid?
   if (!sc.comp_unit)
     return lldb::eLanguageTypeUnknown;
 
-  auto cu = m_session_up->getConcreteSymbolById<PDBSymbolCompiland>(
-      sc.comp_unit->GetID());
-  if (!cu)
+  auto compiland_up = GetPDBCompilandByUID(sc.comp_unit->GetID());
+  if (!compiland_up)
     return lldb::eLanguageTypeUnknown;
-  auto details = cu->findOneChild<PDBSymbolCompilandDetails>();
+  auto details = compiland_up->findOneChild<PDBSymbolCompilandDetails>();
   if (!details)
     return lldb::eLanguageTypeUnknown;
   return TranslateLanguage(details->getLanguage());
 }
 
 size_t SymbolFilePDB::ParseCompileUnitFunctions(
     const lldb_private::SymbolContext &sc) {
   // TODO: Implement this
   return size_t();
 }
 
 bool SymbolFilePDB::ParseCompileUnitLineTable(
     const lldb_private::SymbolContext &sc) {
+  lldbassert(sc.comp_unit);
+  if (sc.comp_unit->GetLineTable())
+    return true;
   return ParseCompileUnitLineTable(sc, 0);
 }
 
 bool SymbolFilePDB::ParseCompileUnitDebugMacros(
     const lldb_private::SymbolContext &sc) {
   // PDB doesn't contain information about macros
   return false;
 }
 
 bool SymbolFilePDB::ParseCompileUnitSupportFiles(
     const lldb_private::SymbolContext &sc,
     lldb_private::FileSpecList &support_files) {
-  if (!sc.comp_unit)
-    return false;
+  lldbassert(sc.comp_unit);
 
   // In theory this is unnecessary work for us, because all of this information
   // is easily (and quickly) accessible from DebugInfoPDB, so caching it a
   // second time seems like a waste.  Unfortunately, there's no good way around
   // this short of a moderate refactor since SymbolVendor depends on being able
   // to cache this list.
-  auto cu = m_session_up->getConcreteSymbolById<PDBSymbolCompiland>(
-      sc.comp_unit->GetID());
-  if (!cu)
+  auto compiland_up = GetPDBCompilandByUID(sc.comp_unit->GetID());
+  if (!compiland_up)
     return false;
-  auto files = m_session_up->getSourceFilesForCompiland(*cu);
+  auto files = m_session_up->getSourceFilesForCompiland(*compiland_up);
   if (!files || files->getChildCount() == 0)
     return false;
 
   while (auto file = files->getNext()) {
-    FileSpec spec(file->getFileName(), false);
-    support_files.Append(spec);
+    FileSpec spec(file->getFileName(), false, FileSpec::ePathSyntaxWindows);
+    support_files.AppendIfUnique(spec);
   }
   return true;
 }
 
 bool SymbolFilePDB::ParseImportedModules(
     const lldb_private::SymbolContext &sc,
     std::vector<lldb_private::ConstString> &imported_modules) {
   // PDB does not yet support module debug info

 bool SymbolFilePDB::CompleteType(lldb_private::CompilerType &compiler_type) {
   // TODO: Implement this
   return false;
 }
 
 lldb_private::CompilerDecl SymbolFilePDB::GetDeclForUID(lldb::user_id_t uid) {
   return lldb_private::CompilerDecl();
 }
 
 lldb_private::CompilerDeclContext
 SymbolFilePDB::GetDeclContextForUID(lldb::user_id_t uid) {
   // PDB always uses the translation unit decl context for everything.  We can
   // improve this later but it's not easy because PDB doesn't provide a high
   // enough level of type fidelity in this area.
   return *m_tu_decl_ctx_up;
 }
 
 lldb_private::CompilerDeclContext
 SymbolFilePDB::GetDeclContextContainingUID(lldb::user_id_t uid) {
   return *m_tu_decl_ctx_up;
 }
 
 void SymbolFilePDB::ParseDeclsForContext(
     lldb_private::CompilerDeclContext decl_ctx) {}
 
 uint32_t
 SymbolFilePDB::ResolveSymbolContext(const lldb_private::Address &so_addr,
                                     uint32_t resolve_scope,
                                     lldb_private::SymbolContext &sc) {
   return uint32_t();
 }
 
+std::string SymbolFilePDB::GetSourceFileNameForPDBCompiland(
+    const PDBSymbolCompiland *pdb_compiland) {
+  if (!pdb_compiland)
+    return std::string();
+
+  std::string source_file_name;
+  // `getSourceFileName` returns the basename of the original source file
+  // used to generate this compiland.  It does not return the full path.
+  // Currently the only way to get that is to do a basename lookup to get the
+  // IPDBSourceFile, but this is ambiguous in the case of two source files
+  // with the same name contributing to the same compiland. This is a
+  // moderately extreme edge case, so we consider this OK for now, although
+  // we need to find a long-term solution.
+  std::string file_name = pdb_compiland->getSourceFileName();
+  if (!file_name.empty()) {
+    auto one_src_file_up =
+      m_session_up->findOneSourceFile(pdb_compiland, file_name,
+                                      PDB_NameSearchFlags::NS_CaseInsensitive);
+    if (one_src_file_up)
+      source_file_name = one_src_file_up->getFileName();
+  }
+  // For some reason, source file name could be empty, so we will walk through
+  // all source files of this compiland, and determine the right source file
+  // if any that is used to generate this compiland based on language
+  // indicated in compilanddetails language field.
+  if (!source_file_name.empty())
+    return source_file_name;
+
+  auto details_up = pdb_compiland->findOneChild<PDBSymbolCompilandDetails>();
+  PDB_Lang pdb_lang = details_up ? details_up->getLanguage() : PDB_Lang::Cpp;
+  auto src_files_up =
+    m_session_up->getSourceFilesForCompiland(*pdb_compiland);
+  if (src_files_up) {
+    while (auto file_up = src_files_up->getNext()) {
+      FileSpec file_spec(file_up->getFileName(), false,
+                         FileSpec::ePathSyntaxWindows);
+      auto file_extension = file_spec.GetFileNameExtension();
+      if (pdb_lang == PDB_Lang::Cpp || pdb_lang == PDB_Lang::C) {
+        static const char* exts[] = { "cpp", "c", "cc", "cxx" };
+        if (llvm::is_contained(exts, file_extension.GetStringRef().lower()))
+          source_file_name = file_up->getFileName();
+        break;
+      } else if (pdb_lang == PDB_Lang::Masm &&
+                 ConstString::Compare(file_extension, ConstString("ASM"),
+                                      false) == 0) {
+        source_file_name = file_up->getFileName();
+        break;
+      }
+    }
+  }
+  return source_file_name;
+}
+
 uint32_t SymbolFilePDB::ResolveSymbolContext(
     const lldb_private::FileSpec &file_spec, uint32_t line, bool check_inlines,
     uint32_t resolve_scope, lldb_private::SymbolContextList &sc_list) {
+  const size_t old_size = sc_list.GetSize();
   if (resolve_scope & lldb::eSymbolContextCompUnit) {
     // Locate all compilation units with line numbers referencing the specified
     // file.  For example, if `file_spec` is <vector>, then this should return
     // all source files and header files that reference <vector>, either
     // directly or indirectly.
     auto compilands = m_session_up->findCompilandsForSourceFile(
         file_spec.GetPath(), PDB_NameSearchFlags::NS_CaseInsensitive);
 
+    if (!compilands)
+      return 0;
+
     // For each one, either find its previously parsed data or parse it afresh
     // and add it to the symbol context list.
     while (auto compiland = compilands->getNext()) {
       // If we're not checking inlines, then don't add line information for this
       // file unless the FileSpec matches.
       if (!check_inlines) {
         // `getSourceFileName` returns the basename of the original source file
         // used to generate this compiland.  It does not return the full path.
         // Currently the only way to get that is to do a basename lookup to get
         // the IPDBSourceFile, but this is ambiguous in the case of two source
         // files with the same name contributing to the same compiland.  This is
         // a moderately extreme edge case, so we consider this OK for now,
         // although we need to find a long-term solution.
-        std::string source_file = compiland->getSourceFileName();
-        auto pdb_file = m_session_up->findOneSourceFile(
-            compiland.get(), source_file,
-            PDB_NameSearchFlags::NS_CaseInsensitive);
-        source_file = pdb_file->getFileName();
+        std::string source_file =
+            GetSourceFileNameForPDBCompiland(compiland.get());
+        if (source_file.empty())
+          continue;
         FileSpec this_spec(source_file, false, FileSpec::ePathSyntaxWindows);
-        if (!file_spec.FileEquals(this_spec))
+        bool need_full_match = !file_spec.GetDirectory().IsEmpty();
+        if (FileSpec::Compare(file_spec, this_spec, need_full_match) != 0)
           continue;
       }
 
       SymbolContext sc;
-      auto cu = ParseCompileUnitForSymIndex(compiland->getSymIndexId());
+      auto cu = ParseCompileUnitForUID(compiland->getSymIndexId());
+      if (!cu.get())
+        continue;
       sc.comp_unit = cu.get();
       sc.module_sp = cu->GetModule();
       sc_list.Append(sc);
 
       // If we were asked to resolve line entries, add all entries to the line
       // table that match the requested line (or all lines if `line` == 0).
       if (resolve_scope & lldb::eSymbolContextLineEntry)
         ParseCompileUnitLineTable(sc, line);
     }
   }
-  return sc_list.GetSize();
+  return sc_list.GetSize() - old_size;
 }
 
 uint32_t SymbolFilePDB::FindGlobalVariables(
     const lldb_private::ConstString &name,
     const lldb_private::CompilerDeclContext *parent_decl_ctx, bool append,
     uint32_t max_matches, lldb_private::VariableList &variables) {
   return uint32_t();
 }
SymbolFilePDB::FindTypesByRegex(const lldb_private::RegularExpression &regex,
   // When searching by regex, we need to go out of our way to limit the search
   // space as much as possible since this searches EVERYTHING in the PDB,
   // manually doing regex comparisons.  PDB library isn't optimized for regex
   // searches or searches across multiple symbol types at the same time, so the
   // best we can do is to search enums, then typedefs, then classes one by one,
   // and do a regex comparison against each of them.
   PDB_SymType tags_to_search[] = {PDB_SymType::Enum, PDB_SymType::Typedef,
                                   PDB_SymType::UDT};
-  auto global = m_session_up->getGlobalScope();
   std::unique_ptr<IPDBEnumSymbols> results;
 
   uint32_t matches = 0;
 
   for (auto tag : tags_to_search) {
-    results = global->findAllChildren(tag);
+    results = m_global_scope_up->findAllChildren(tag);
+    if (!results)
+      continue;
+
     while (auto result = results->getNext()) {
       if (max_matches > 0 && matches >= max_matches)
         break;
 
       std::string type_name;
       if (auto enum_type = llvm::dyn_cast<PDBSymbolTypeEnum>(result.get()))
         type_name = enum_type->getName();
       else if (auto typedef_type =
while (auto result = results->getNext()) {
       ++matches;
     }
   }
 }
 
 void SymbolFilePDB::FindTypesByName(const std::string &name,
                                     uint32_t max_matches,
                                     lldb_private::TypeMap &types) {
-  auto global = m_session_up->getGlobalScope();
   std::unique_ptr<IPDBEnumSymbols> results;
-  results = global->findChildren(PDB_SymType::None, name,
+  results = m_global_scope_up->findChildren(PDB_SymType::None, name,
                                             PDB_NameSearchFlags::NS_Default);
+  if (!results)
+    return;
 
   uint32_t matches = 0;
 
   while (auto result = results->getNext()) {
     if (max_matches > 0 && matches >= max_matches)
       break;
     switch (result->getSymTag()) {
     case PDB_SymType::Enum:
lldb_private::CompilerDeclContext SymbolFilePDB::FindNamespace(
     const lldb_private::CompilerDeclContext *parent_decl_ctx) {
   return lldb_private::CompilerDeclContext();
 }
 
 lldb_private::ConstString SymbolFilePDB::GetPluginName() {
   static ConstString g_name("pdb");
   return g_name;
 }
 
 uint32_t SymbolFilePDB::GetPluginVersion() { return 1; }
 
 IPDBSession &SymbolFilePDB::GetPDBSession() { return *m_session_up; }
 
 const IPDBSession &SymbolFilePDB::GetPDBSession() const {
   return *m_session_up;
 }
 
-lldb::CompUnitSP SymbolFilePDB::ParseCompileUnitForSymIndex(uint32_t id) {
+lldb::CompUnitSP
+SymbolFilePDB::ParseCompileUnitForUID(uint32_t id, uint32_t index) {
   auto found_cu = m_comp_units.find(id);
   if (found_cu != m_comp_units.end())
     return found_cu->second;
 
-  auto cu = m_session_up->getConcreteSymbolById<PDBSymbolCompiland>(id);
-
-  // `getSourceFileName` returns the basename of the original source file used
-  // to generate this compiland.  It does not return the full path.  Currently
-  // the only way to get that is to do a basename lookup to get the
-  // IPDBSourceFile, but this is ambiguous in the case of two source files with
-  // the same name contributing to the same compiland. This is a moderately
-  // extreme edge case, so we consider this OK for now, although we need to find
-  // a long-term solution.
-  auto file =
-      m_session_up->findOneSourceFile(cu.get(), cu->getSourceFileName(),
-                                      PDB_NameSearchFlags::NS_CaseInsensitive);
-  std::string path = file->getFileName();
+  auto compiland_up = GetPDBCompilandByUID(id);
+  if (!compiland_up)
+    return CompUnitSP();
+  std::string path = GetSourceFileNameForPDBCompiland(compiland_up.get());
+  if (path.empty())
+    return CompUnitSP();
 
   lldb::LanguageType lang;
-  auto details = cu->findOneChild<PDBSymbolCompilandDetails>();
+  auto details = compiland_up->findOneChild<PDBSymbolCompilandDetails>();
   if (!details)
     lang = lldb::eLanguageTypeC_plus_plus;
   else
     lang = TranslateLanguage(details->getLanguage());
 
   // Don't support optimized code for now, DebugInfoPDB does not return this
   // information.
   LazyBool optimized = eLazyBoolNo;
-  auto result = std::make_shared<CompileUnit>(
+  auto cu_sp = std::make_shared<CompileUnit>(
       m_obj_file->GetModule(), nullptr, path.c_str(), id, lang, optimized);
-  m_comp_units.insert(std::make_pair(id, result));
-  return result;
+
+  if (!cu_sp)
+    return CompUnitSP();
+
+  m_comp_units.insert(std::make_pair(id, cu_sp));
+  if (index == UINT32_MAX)
+    GetCompileUnitIndex(compiland_up.get(), index);
+  lldbassert(index != UINT32_MAX);
+  m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex(
+      index, cu_sp);
+  return cu_sp;
 }
 
 bool SymbolFilePDB::ParseCompileUnitLineTable(
     const lldb_private::SymbolContext &sc, uint32_t match_line) {
-  auto global = m_session_up->getGlobalScope();
-  auto cu = m_session_up->getConcreteSymbolById<PDBSymbolCompiland>(
-      sc.comp_unit->GetID());
+  lldbassert(sc.comp_unit);
+
+  auto compiland_up = GetPDBCompilandByUID(sc.comp_unit->GetID());
+  if (!compiland_up)
+    return false;
 
   // LineEntry needs the *index* of the file into the list of support files
   // returned by ParseCompileUnitSupportFiles.  But the underlying SDK gives us
   // a globally unique idenfitifier in the namespace of the PDB.  So, we have to
   // do a mapping so that we can hand out indices.
   llvm::DenseMap<uint32_t, uint32_t> index_map;
-  BuildSupportFileIdToSupportFileIndexMap(*cu, index_map);
+  BuildSupportFileIdToSupportFileIndexMap(*compiland_up, index_map);
   auto line_table = llvm::make_unique<LineTable>(sc.comp_unit);
 
-  // Find contributions to `cu` from all source and header files.
+  // Find contributions to `compiland` from all source and header files.
   std::string path = sc.comp_unit->GetPath();
-  auto files = m_session_up->getSourceFilesForCompiland(*cu);
+  auto files = m_session_up->getSourceFilesForCompiland(*compiland_up);
+  if (!files)
+    return false;
 
   // For each source and header file, create a LineSequence for contributions to
-  // the cu from that file, and add the sequence.
+  // the compiland from that file, and add the sequence.
   while (auto file = files->getNext()) {
     std::unique_ptr<LineSequence> sequence(
         line_table->CreateLineSequenceContainer());
-    auto lines = m_session_up->findLineNumbers(*cu, *file);
+    auto lines = m_session_up->findLineNumbers(*compiland_up, *file);
+    if (!lines)
+      continue;
     int entry_count = lines->getChildCount();
 
     uint64_t prev_addr;
     uint32_t prev_length;
     uint32_t prev_line;
     uint32_t prev_source_idx;
 
     for (int i = 0; i < entry_count; ++i) {
       auto line = lines->getChildAtIndex(i);
 
       uint64_t lno = line->getLineNumber();
       uint64_t addr = line->getVirtualAddress();
       uint32_t length = line->getLength();
       uint32_t source_id = line->getSourceFileId();
       uint32_t col = line->getColumnNumber();
       uint32_t source_idx = index_map[source_id];
for (int i = 0; i < entry_count; ++i) {
       if (ShouldAddLine(match_line, lno, length)) {
         bool is_statement = line->isStatement();
         bool is_prologue = false;
         bool is_epilogue = false;
         auto func =
             m_session_up->findSymbolByAddress(addr, PDB_SymType::Function);
         if (func) {
           auto prologue = func->findOneChild<PDBSymbolFuncDebugStart>();
+          if (prologue)
             is_prologue = (addr == prologue->getVirtualAddress());
 
           auto epilogue = func->findOneChild<PDBSymbolFuncDebugEnd>();
+          if (epilogue)
             is_epilogue = (addr == epilogue->getVirtualAddress());
         }
 
         line_table->AppendLineEntryToSequence(sequence.get(), addr, lno, col,
                                               source_idx, is_statement, false,
                                               is_prologue, is_epilogue, false);
       }
 
       prev_addr = addr;
       prev_length = length;
       prev_line = lno;
       prev_source_idx = source_idx;
     }
 
     if (entry_count > 0 && ShouldAddLine(match_line, prev_line, prev_length)) {
       // The end is always a terminal entry, so insert it regardless.
       line_table->AppendLineEntryToSequence(
           sequence.get(), prev_addr + prev_length, prev_line, 0,
           prev_source_idx, false, false, false, false, true);
     }
 
     line_table->InsertSequence(sequence.release());
   }
 
+  if (line_table->GetSize()) {
     sc.comp_unit->SetLineTable(line_table.release());
     return true;
   }
+  return false;
+}
 
 void SymbolFilePDB::BuildSupportFileIdToSupportFileIndexMap(
-    const PDBSymbolCompiland &cu,
+    const PDBSymbolCompiland &compiland,
     llvm::DenseMap<uint32_t, uint32_t> &index_map) const {
   // This is a hack, but we need to convert the source id into an index into the
   // support files array.  We don't want to do path comparisons to avoid
   // basename / full path issues that may or may not even be a problem, so we
   // use the globally unique source file identifiers.  Ideally we could use the
   // global identifiers everywhere, but LineEntry currently assumes indices.
-  auto source_files = m_session_up->getSourceFilesForCompiland(cu);
+  auto source_files = m_session_up->getSourceFilesForCompiland(compiland);
+  if (!source_files)
+    return;
   int index = 0;
 
   while (auto file = source_files->getNext()) {
     uint32_t source_id = file->getUniqueId();
     index_map[source_id] = index++;
   }
 }