[lldb][Mangled] Retrieve and cache demangled name info

Author: Michael137

lldb/include/lldb/Core/Mangled.h

@@ -9,11 +9,13 @@
 #ifndef LLDB_CORE_MANGLED_H
 #define LLDB_CORE_MANGLED_H
 
+#include "lldb/Core/Demangle.h"
+#include "lldb/Utility/ConstString.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-types.h"
-#include "lldb/Utility/ConstString.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Demangle/Utility.h"
 
 #include <cstddef>
 #include <memory>
@@ -275,6 +277,8 @@ class Mangled {
   ///   table offsets in the cache data.
   void Encode(DataEncoder &encoder, ConstStringTable &strtab) const;
 
+  const std::optional<FunctionNameInfo> &GetDemangledInfo() const;
+
 private:
   /// If \c force is \c false, this function will re-use the previously
   /// demangled name (if any). If \c force is \c true (or the mangled name
@@ -288,6 +292,11 @@ class Mangled {
   ///< Mutable so we can get it on demand with
   ///< a const version of this object.
   mutable ConstString m_demangled;
+
+  /// If available, holds details information about where
+  /// in \c m_demangled parts of the name begin end (e.g.,
+  /// basename, arguments, etc.).
+  mutable std::optional<FunctionNameInfo> m_demangled_info = std::nullopt;
 };
 
 Stream &operator<<(Stream &s, const Mangled &obj);

lldb/include/lldb/Symbol/Function.h

@@ -11,6 +11,7 @@
 
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/Declaration.h"
+#include "lldb/Core/Demangle.h"
 #include "lldb/Core/Mangled.h"
 #include "lldb/Expression/DWARFExpressionList.h"
 #include "lldb/Symbol/Block.h"
@@ -534,6 +535,8 @@ class Function : public UserID, public SymbolContextScope {
 
   ConstString GetDisplayName() const;
 
+  const std::optional<FunctionNameInfo> &GetDemangledInfo() const;
+
   const Mangled &GetMangled() const { return m_mangled; }
 
   /// Get the DeclContext for this function, if available.

lldb/source/Core/Mangled.cpp

@@ -9,6 +9,7 @@
 #include "lldb/Core/Mangled.h"
 
 #include "lldb/Core/DataFileCache.h"
+#include "lldb/Core/Demangle.h"
 #include "lldb/Core/RichManglingContext.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Utility/ConstString.h"
@@ -22,6 +23,7 @@
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Demangle/Demangle.h"
+#include "llvm/Demangle/Utility.h"
 #include "llvm/Support/Compiler.h"
 
 #include <mutex>
@@ -152,16 +154,21 @@ static char *GetMSVCDemangledStr(llvm::StringRef M) {
   return demangled_cstr;
 }
 
-static char *GetItaniumDemangledStr(const char *M) {
+static std::pair<char *, FunctionNameInfo>
+GetItaniumDemangledStr(const char *M) {
   char *demangled_cstr = nullptr;
 
+  FunctionNameInfo info;
   llvm::ItaniumPartialDemangler ipd;
   bool err = ipd.partialDemangle(M);
   if (!err) {
     // Default buffer and size (will realloc in case it's too small).
     size_t demangled_size = 80;
     demangled_cstr = static_cast<char *>(std::malloc(demangled_size));
-    demangled_cstr = ipd.finishDemangle(demangled_cstr, &demangled_size);
+
+    TrackingOutputBuffer OB(demangled_cstr, demangled_size);
+    demangled_cstr = ipd.finishDemangle(&OB, &demangled_size);
+    info = std::move(OB.FunctionInfo);
 
     assert(demangled_cstr &&
            "finishDemangle must always succeed if partialDemangle did");
@@ -174,9 +181,14 @@ static char *GetItaniumDemangledStr(const char *M) {
       LLDB_LOGF(log, "demangled itanium: %s -> \"%s\"", M, demangled_cstr);
     else
       LLDB_LOGF(log, "demangled itanium: %s -> error: failed to demangle", M);
+
+    if (!info.hasBasename())
+      LLDB_LOGF(log,
+                "demangled itanium: %s -> error: failed to retrieve name info",
+                M);
   }
 
-  return demangled_cstr;
+  return {demangled_cstr, std::move(info)};
 }
 
 static char *GetRustV0DemangledStr(llvm::StringRef M) {
@@ -269,6 +281,13 @@ ConstString Mangled::GetDemangledName() const {
   return GetDemangledNameImpl(/*force=*/false);
 }
 
+std::optional<FunctionNameInfo> const &Mangled::GetDemangledInfo() const {
+  if (!m_demangled_info)
+    GetDemangledNameImpl(/*force=*/true);
+
+  return m_demangled_info;
+}
+
 // Generate the demangled name on demand using this accessor. Code in this
 // class will need to use this accessor if it wishes to decode the demangled
 // name. The result is cached and will be kept until a new string value is
@@ -293,7 +312,10 @@ ConstString Mangled::GetDemangledNameImpl(bool force) const {
     demangled_name = GetMSVCDemangledStr(m_mangled);
     break;
   case eManglingSchemeItanium: {
-    demangled_name = GetItaniumDemangledStr(m_mangled.GetCString());
+    std::pair<char *, FunctionNameInfo> demangled =
+        GetItaniumDemangledStr(m_mangled.GetCString());
+    demangled_name = demangled.first;
+    m_demangled_info = std::move(demangled.second);
     break;
   }
   case eManglingSchemeRustV0:

lldb/source/Symbol/Function.cpp

@@ -729,3 +729,7 @@ ConstString Function::GetName() const {
 ConstString Function::GetNameNoArguments() const {
   return m_mangled.GetName(Mangled::ePreferDemangledWithoutArguments);
 }
+
+const std::optional<FunctionNameInfo> &Function::GetDemangledInfo() const {
+  return m_mangled.GetDemangledInfo();
+}

llvm/include/llvm/Demangle/Demangle.h

@@ -92,6 +92,7 @@ struct ItaniumPartialDemangler {
   /// Just print the entire mangled name into Buf. Buf and N behave like the
   /// second and third parameters to __cxa_demangle.
   char *finishDemangle(char *Buf, size_t *N) const;
+  char *finishDemangle(void *OB, size_t *N) const;
 
   /// Get the base name of a function. This doesn't include trailing template
   /// arguments, ie for "a::b<int>" this function returns "b".

llvm/lib/Demangle/ItaniumDemangle.cpp

@@ -421,6 +421,14 @@ static char *printNode(const Node *RootNode, char *Buf, size_t *N) {
   return OB.getBuffer();
 }
 
+static char *printNode(const Node *RootNode, OutputBuffer &OB, size_t *N) {
+  RootNode->print(OB);
+  OB += '\0';
+  if (N != nullptr)
+    *N = OB.getCurrentPosition();
+  return OB.getBuffer();
+}
+
 char *ItaniumPartialDemangler::getFunctionBaseName(char *Buf, size_t *N) const {
   if (!isFunction())
     return nullptr;
@@ -540,6 +548,13 @@ char *ItaniumPartialDemangler::finishDemangle(char *Buf, size_t *N) const {
   return printNode(static_cast<Node *>(RootNode), Buf, N);
 }
 
+char *ItaniumPartialDemangler::finishDemangle(void *OB, size_t *N) const {
+  assert(RootNode != nullptr && "must call partialDemangle()");
+  assert(OB != nullptr && "valid OutputBuffer argument required");
+  return printNode(static_cast<Node *>(RootNode),
+                   *static_cast<OutputBuffer *>(OB), N);
+}
+
 bool ItaniumPartialDemangler::hasFunctionQualifiers() const {
   assert(RootNode != nullptr && "must call partialDemangle()");
   if (!isFunction())