================
@@ -1641,6 +1642,94 @@ void SymbolFileNativePDB::DumpClangAST(Stream &s,
llvm::StringRef filter) {
clang->GetNativePDBParser()->Dump(s, filter);
}
+void SymbolFileNativePDB::CacheFunctionNames() {
+ if (!m_func_full_names.IsEmpty())
+ return;
+
+ // (segment, code offset) -> gid
+ std::map<std::pair<uint16_t, uint32_t>, uint32_t> addr_ids;
+
+ // First, find all function references in the globals table.
+ for (const uint32_t gid : m_index->globals().getGlobalsTable()) {
+ CVSymbol ref_sym = m_index->symrecords().readRecord(gid);
+ auto kind = ref_sym.kind();
+ if (kind != S_PROCREF && kind != S_LPROCREF)
+ continue;
+
+ ProcRefSym ref =
+ llvm::cantFail(SymbolDeserializer::deserializeAs<ProcRefSym>(ref_sym));
+ if (ref.Name.empty())
+ continue;
+
+ // Find the function this is referencing
+ CompilandIndexItem &cci =
+ m_index->compilands().GetOrCreateCompiland(ref.modi());
+ auto iter = cci.m_debug_stream.getSymbolArray().at(ref.SymOffset);
+ if (iter == cci.m_debug_stream.getSymbolArray().end())
+ continue;
+ kind = iter->kind();
+ if (kind != S_GPROC32 && kind != S_LPROC32)
+ continue;
+
+ ProcSym proc =
+ llvm::cantFail(SymbolDeserializer::deserializeAs<ProcSym>(*iter));
+ if ((proc.Flags & ProcSymFlags::IsUnreachable) != ProcSymFlags::None)
+ continue;
+ if (proc.Name.empty())
+ continue;
+
+ // The function/procedure symbol only contains the demangled name.
+ // The mangled names are in the publics table. Save the address of this
+ // function to lookup the mangled name later.
+ addr_ids.emplace(std::make_pair(proc.Segment, proc.CodeOffset), gid);
+
+ llvm::StringRef basename = MSVCUndecoratedNameParser::DropScope(proc.Name);
+ if (basename.empty())
+ basename = proc.Name;
+
+ m_func_base_names.Append(ConstString(basename), gid);
+ m_func_full_names.Append(ConstString(proc.Name), gid);
+
+ // To see if this is a member function, check the type
+ auto type = m_index->tpi().getType(proc.FunctionType);
+ if (type.kind() == LF_MFUNCTION) {
+ MemberFunctionRecord mfr;
+ llvm::cantFail(
+ TypeDeserializer::deserializeAs<MemberFunctionRecord>(type, mfr));
+ if (!mfr.getThisType().isNoneType())
+ m_func_method_names.Append(ConstString(basename), gid);
+ }
+ }
+
+ // The publics stream contains all mangled function names and their address.
+ for (auto pid : m_index->publics().getPublicsTable()) {
+ PdbGlobalSymId global{pid, true};
+ CVSymbol sym = m_index->ReadSymbolRecord(global);
+ auto kind = sym.kind();
+ if (kind != S_PUB32)
+ continue;
+ PublicSym32 pub =
+ llvm::cantFail(SymbolDeserializer::deserializeAs<PublicSym32>(sym));
+ // We only care about mangled names - if the name isn't mangled, it's
+ // already in the full name map
+ if (!Mangled::IsMangledName(pub.Name))
+ continue;
+
+ // Check if this symbol is for one of our functions
----------------
JDevlieghere wrote:
```suggestion
// Check if this symbol is for one of our functions.
```
https://github.com/llvm/llvm-project/pull/152295
_______________________________________________
lldb-commits mailing list
lldb-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
