[SymbolFilePDB] Minor cleanup

[asmith]

Summary

• Remove unused code

• Adding break statement conditionally

• Ignore empty strings in FindTypeByName

[zturner]

source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

499

Why would this return nullptr?

[asmith]

source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

499

No idea but it does.

TypeList *Module::GetTypeList() {

SymbolVendor *symbols = GetSymbolVendor();
if (symbols)
  return &symbols->GetTypeList();
return nullptr;

}

source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

SymbolFilePDB::ParseCompileUnitFunctionForPDBFunc(
 
   auto func_length = pdb_func->getLength();
   AddressRange func_range = AddressRange(file_vm_addr,
                                          func_length,
                                          sc.module_sp->GetSectionList());
   if (!func_range.GetBaseAddress().IsValid())
     return nullptr;
 
-  user_id_t func_type_uid = pdb_func->getSignatureId();
-  // TODO: Function symbol with invalid signature won't be handled. We'll set up
-  // a white list to trace them.
-  if (!pdb_func->getSignature())
-    return nullptr;
-
   lldb_private::Type* func_type = ResolveTypeUID(pdb_func->getSymIndexId());
   if (!func_type)
     return nullptr;
 
+  user_id_t func_type_uid = pdb_func->getSignatureId();
+
   Mangled mangled = GetMangledForPDBFunc(pdb_func);
 
   FunctionSP func_sp = std::make_shared<Function>(sc.comp_unit,
                                                   pdb_func->getSymIndexId(),
                                                   func_type_uid,
                                                   mangled,
                                                   func_type,
                                                   func_range);
lldb_private::Type *SymbolFilePDB::ResolveTypeUID(lldb::user_id_t type_uid) {
   auto pdb_type = m_session_up->getSymbolById(type_uid);
   if (pdb_type == nullptr)
     return nullptr;
 
   lldb::TypeSP result = pdb->CreateLLDBTypeFromPDBType(*pdb_type);
   if (result.get()) {
     m_types.insert(std::make_pair(type_uid, result));
     auto type_list = GetTypeList();
+    if (type_list)
       type_list->Insert(result);
   }
   return result.get();
 }
 
 bool SymbolFilePDB::CompleteType(lldb_private::CompilerType &compiler_type) {
   // TODO: Implement this
   return false;
 }
std::string SymbolFilePDB::GetSourceFileNameForPDBCompiland(
   // 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 an edge
   // case that we ignore for now, although we need to 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()))
while (auto compiland = compilands->getNext()) {
       // table that match the requested line (or all lines if `line` == 0).
       if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock |
                            eSymbolContextLineEntry)) {
         bool has_line_table = ParseCompileUnitLineTable(sc, line);
 
         if ((resolve_scope & eSymbolContextLineEntry) && !has_line_table) {
           // The query asks for line entries, but we can't get them for the
           // compile unit. This is not normal for `line` = 0. So just assert it.
-          if (line == 0) {
-            assert(0 && "Couldn't get all line entries!\n");
-          }
+          assert(line && "Couldn't get all line entries!\n");
 
           // Current compiland does not have the requested line. Search next.
           continue;
         }
 
         if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock)) {
           if (!has_line_table)
             continue;

 void SymbolFilePDB::CacheFunctionNames() {
   if (!m_func_full_names.IsEmpty())
     return;
 
   std::map<uint64_t, uint32_t> addr_ids;
 
   if (auto results_up = m_global_scope_up->findAllChildren<PDBSymbolFunc>()) {
     while (auto pdb_func_up = results_up->getNext()) {
-      auto uid = pdb_func_up->getSymIndexId();
+      if (pdb_func_up->isCompilerGenerated())
+        continue;
+
       auto name = pdb_func_up->getName();
       auto demangled_name = pdb_func_up->getUndecoratedName();
       if (name.empty() && demangled_name.empty())
         continue;
-      if (pdb_func_up->isCompilerGenerated())
-        continue;
 
+      auto uid = pdb_func_up->getSymIndexId();
       if (!demangled_name.empty() && pdb_func_up->getVirtualAddress())
         addr_ids.insert(std::make_pair(pdb_func_up->getVirtualAddress(), uid));
 
       if (auto parent = pdb_func_up->getClassParent()) {
 
         // PDB have symbols for class/struct methods or static methods in Enum
         // Class. We won't bother to check if the parent is UDT or Enum here.
         m_func_method_names.Append(ConstString(name), uid);
if (auto results_up =
     while (auto pub_sym_up = results_up->getNext()) {
       if (!pub_sym_up->isFunction())
         continue;
       auto name = pub_sym_up->getName();
       if (name.empty())
         continue;
 
       if (CPlusPlusLanguage::IsCPPMangledName(name.c_str())) {
-        auto demangled_name = pub_sym_up->getUndecoratedName();
-        std::vector<uint32_t> ids;
         auto vm_addr = pub_sym_up->getVirtualAddress();
 
         // PDB public symbol has mangled name for its associated function.
         if (vm_addr && addr_ids.find(vm_addr) != addr_ids.end()) {
           // Cache mangled name.
           m_func_full_names.Append(ConstString(name), addr_ids[vm_addr]);
         }
       }
for (auto tag : tags_to_search) {
     }
   }
 }
 
 void SymbolFilePDB::FindTypesByName(const std::string &name,
                                     uint32_t max_matches,
                                     lldb_private::TypeMap &types) {
   std::unique_ptr<IPDBEnumSymbols> results;
+  if (name.empty())
+    return;
   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()) {

 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 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 = compiland_up->findOneChild<PDBSymbolCompilandDetails>();
   if (!details)
     lang = lldb::eLanguageTypeC_plus_plus;
   else
     lang = TranslateLanguage(details->getLanguage());
 
+  if (lang == lldb::LanguageType::eLanguageTypeUnknown)
+    return CompUnitSP();
+
+  std::string path = GetSourceFileNameForPDBCompiland(compiland_up.get());
+  if (path.empty())
+    return CompUnitSP();
+
   // Don't support optimized code for now, DebugInfoPDB does not return this
   // information.
   LazyBool optimized = eLazyBoolNo;
   auto cu_sp = std::make_shared<CompileUnit>(
       m_obj_file->GetModule(), nullptr, path.c_str(), id, lang, optimized);
 
   if (!cu_sp)
     return CompUnitSP();
auto result_up =
         m_global_scope_up->findChildren(PDB_SymType::PublicSymbol,
                                         func_undecorated_name,
                                         PDB_NameSearchFlags::NS_UndecoratedName);
     if (result_up) {
       while (auto symbol_up = result_up->getNext()) {
         // For a public symbol, it is unique.
         lldbassert(result_up->getChildCount() == 1);
         if (auto *pdb_public_sym =
-            llvm::dyn_cast<PDBSymbolPublicSymbol>(symbol_up.get())) {
+            llvm::dyn_cast_or_null<PDBSymbolPublicSymbol>(symbol_up.get())) {
           if (pdb_public_sym->isFunction()) {
             func_decorated_name = pdb_public_sym->getName();
+            break;
           }
         }
       }
     }
   }
   if (!func_decorated_name.empty()) {
     mangled.SetMangledName(ConstString(func_decorated_name));