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

Author: Michael137

lldb/include/lldb/Core/Mangled.h

@@ -9,11 +9,12 @@
 #ifndef LLDB_CORE_MANGLED_H
 #define LLDB_CORE_MANGLED_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 +276,10 @@ class Mangled {
   ///   table offsets in the cache data.
   void Encode(DataEncoder &encoder, ConstStringTable &strtab) const;
 
+  using DemangledInfo = llvm::itanium_demangle::OutputBuffer::FunctionNameInfo;
+
+  const DemangledInfo &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 +293,9 @@ class Mangled {
   ///< Mutable so we can get it on demand with
   ///< a const version of this object.
   mutable ConstString m_demangled;
+
+  // TODO: should this be an optional?
+  mutable DemangledInfo m_demangled_info;
 };
 
 Stream &operator<<(Stream &s, const Mangled &obj);

lldb/include/lldb/Symbol/Function.h

@@ -534,6 +534,8 @@ class Function : public UserID, public SymbolContextScope {
 
   ConstString GetDisplayName() const;
 
+  Mangled::DemangledInfo GetDemangledInfo() const;
+
   const Mangled &GetMangled() const { return m_mangled; }
 
   /// Get the DeclContext for this function, if available.

lldb/source/Core/Mangled.cpp

@@ -22,6 +22,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 +153,21 @@ static char *GetMSVCDemangledStr(llvm::StringRef M) {
   return demangled_cstr;
 }
 
-static char *GetItaniumDemangledStr(const char *M) {
+static std::pair<char *, Mangled::DemangledInfo>
+GetItaniumDemangledStr(const char *M) {
   char *demangled_cstr = nullptr;
 
+  Mangled::DemangledInfo 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);
+
+    llvm::itanium_demangle::OutputBuffer 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 +180,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 +280,16 @@ ConstString Mangled::GetDemangledName() const {
   return GetDemangledNameImpl(/*force=*/false);
 }
 
+const Mangled::DemangledInfo &Mangled::GetDemangledInfo() const {
+  // TODO: if setting m_demangled_info previously failed
+  // we still end up re-demangling. If m_demangled_info
+  // was an optional we could prevent that.
+  if (!m_demangled_info.hasBasename())
+    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 +314,10 @@ ConstString Mangled::GetDemangledNameImpl(bool force) const {
     demangled_name = GetMSVCDemangledStr(m_mangled);
     break;
   case eManglingSchemeItanium: {
-    demangled_name = GetItaniumDemangledStr(m_mangled.GetCString());
+    std::pair<char *, Mangled::DemangledInfo> 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);
 }
+
+Mangled::DemangledInfo 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())