fix: check function type to get calling convention

Author: Nerixyz

lldb/source/Plugins/SymbolFile/NativePDB/PdbUtil.cpp

@@ -1118,21 +1118,3 @@ size_t lldb_private::npdb::GetSizeOfType(PdbTypeSymId id,
   }
   return 0;
 }
-
-llvm::StringRef lldb_private::npdb::StripCDeclPrefix(llvm::StringRef mangled) {
-  // See
-  // https://learn.microsoft.com/en-us/cpp/build/reference/decorated-names#FormatC
-  if (!mangled.starts_with('_'))
-    return mangled;
-
-  // make sure this isn't __stdcall (`_{name}@{sizeof(params)}`) or __vectorcall
-  // (`{name}@@{sizeof(params)}`).
-  size_t last_at_pos = mangled.find_last_of('@');
-  if (last_at_pos != llvm::StringRef::npos &&
-      last_at_pos < mangled.size() - 1 &&
-      llvm::all_of(mangled.slice(last_at_pos + 1, mangled.size()),
-                   llvm::isDigit))
-    return mangled;
-
-  return mangled.drop_front();
-}

lldb/source/Plugins/SymbolFile/NativePDB/PdbUtil.h

@@ -161,18 +161,6 @@ PdbTypeSymId GetBestPossibleDecl(PdbTypeSymId id, llvm::pdb::TpiStream &tpi);
 
 size_t GetSizeOfType(PdbTypeSymId id, llvm::pdb::TpiStream &tpi);
 
-/// Strips the leading underscore of mangled __cdecl functions.
-///
-/// If the name comes from another calling convention, it is returned as-is.
-///
-/// \pre \c mangled must not be from a 64-bit environment as __cdecl names
-///     aren't mangled there.
-///
-/// \param[in] mangled A mangled symbol name
-/// \returns The stripped name if this name is a mangled __cdecl one. Otherwise,
-///     the input is returned.
-llvm::StringRef StripCDeclPrefix(llvm::StringRef mangled);
-
 } // namespace npdb
 } // namespace lldb_private
 

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

@@ -501,9 +501,13 @@ lldb::FunctionSP SymbolFileNativePDB::CreateFunction(PdbCompilandSymId func_id,
     return nullptr;
 
   PdbTypeSymId sig_id(proc.FunctionType, false);
+
   std::optional<llvm::StringRef> mangled_opt =
       FindMangledSymbol(SegmentOffset(proc.Segment, proc.CodeOffset));
+  if (mangled_opt)
+    mangled_opt = StripMangledFunctionName(*mangled_opt, proc.FunctionType);
   Mangled mangled(mangled_opt.value_or(proc.Name));
+
   FunctionSP func_sp = std::make_shared<Function>(
       &comp_unit, toOpaqueUid(func_id), toOpaqueUid(sig_id), mangled,
       func_type.get(), func_addr,
@@ -2678,7 +2682,11 @@ SymbolFileNativePDB::FindMangledFunctionName(PdbCompilandSymId func_id) {
   ProcSym proc(static_cast<SymbolRecordKind>(sym_record.kind()));
   cantFail(SymbolDeserializer::deserializeAs<ProcSym>(sym_record, proc));
 
-  return FindMangledSymbol(SegmentOffset(proc.Segment, proc.CodeOffset));
+  std::optional<llvm::StringRef> mangled =
+      FindMangledSymbol(SegmentOffset(proc.Segment, proc.CodeOffset));
+  if (mangled)
+    mangled = StripMangledFunctionName(*mangled, proc.FunctionType);
+  return mangled;
 }
 
 std::optional<llvm::StringRef>
@@ -2688,20 +2696,48 @@ SymbolFileNativePDB::FindMangledSymbol(SegmentOffset so) {
   if (!symbol)
     return std::nullopt;
 
-  llvm::StringRef name = symbol->first.Name;
+  return symbol->first.Name;
+}
+
+llvm::StringRef
+SymbolFileNativePDB::StripMangledFunctionName(const llvm::StringRef mangled,
+                                              PdbTypeSymId func_ty) {
   // "In non-64 bit environments" (on x86 in pactice), __cdecl functions get
   // prefixed with an underscore. For compilers using LLVM, this happens in LLVM
   // (as opposed to the compiler frontend). Because of this, DWARF doesn't
   // contain the "full" mangled name in DW_AT_linkage_name for these functions.
   // We strip the mangling here for compatibility with DWARF. See
   // llvm.org/pr161676 and
   // https://learn.microsoft.com/en-us/cpp/build/reference/decorated-names#FormatC
-  if ((symbol->first.Flags & PublicSymFlags::Function) !=
-          PublicSymFlags::None &&
-      m_index->dbi().getMachineType() == PDB_Machine::x86)
-    name = StripCDeclPrefix(name);
 
-  return name;
+  if (!mangled.starts_with('_') ||
+      m_index->dbi().getMachineType() != PDB_Machine::x86)
+    return mangled;
+
+  CVType cvt = m_index->tpi().getType(func_ty.index);
+  PDB_CallingConv cc = PDB_CallingConv::NearC;
+  if (cvt.kind() == LF_PROCEDURE) {
+    ProcedureRecord proc;
+    if (llvm::Error error =
+            TypeDeserializer::deserializeAs<ProcedureRecord>(cvt, proc))
+      llvm::consumeError(std::move(error));
+    cc = proc.CallConv;
+  } else if (cvt.kind() == LF_MFUNCTION) {
+    MemberFunctionRecord mfunc;
+    if (llvm::Error error =
+            TypeDeserializer::deserializeAs<MemberFunctionRecord>(cvt, mfunc))
+      llvm::consumeError(std::move(error));
+    cc = mfunc.CallConv;
+  } else {
+    LLDB_LOG(GetLog(LLDBLog::Symbols), "Unexpected function type, got {0}",
+             cvt.kind());
+    return mangled;
+  }
+
+  if (cc == PDB_CallingConv::NearC || cc == PDB_CallingConv::FarC)
+    return mangled.drop_front();
+
+  return mangled;
 }
 
 void SymbolFileNativePDB::CacheUdtDeclarations() {

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

@@ -277,6 +277,9 @@ class SymbolFileNativePDB : public SymbolFileCommon {
 
   std::optional<llvm::StringRef> FindMangledSymbol(SegmentOffset so);
 
+  llvm::StringRef StripMangledFunctionName(llvm::StringRef mangled,
+                                           PdbTypeSymId func_ty);
+
   llvm::BumpPtrAllocator m_allocator;
 
   lldb::addr_t m_obj_load_address = 0;

lldb/unittests/SymbolFile/NativePDB/CMakeLists.txt

@@ -1,6 +1,5 @@
 add_lldb_unittest(SymbolFileNativePDBTests
   PdbFPOProgramToDWARFExpressionTests.cpp
-  PdbUtilTests.cpp
   UdtRecordCompleterTests.cpp
 
   LINK_COMPONENTS