[lldb][Mangled] Add API to force re-demangling a Mangled object (llvm#131836)

Add version of GetDemangledName that will force re-demangling. This is required because LLDB will SetDemangledName without going through the demangler. So we need a way to force demangling to set the m_demangled_info member when we need it.

llvm#131836
(cherry picked from commit f220ea2)

Author: Michael137

lldb/include/lldb/Core/Mangled.h

@@ -277,10 +277,19 @@ class Mangled {
   void Encode(DataEncoder &encoder, ConstStringTable &strtab) const;
 
 private:
-  /// Mangled member variables.
-  ConstString m_mangled;           ///< The mangled version of the name
-  mutable ConstString m_demangled; ///< Mutable so we can get it on demand with
-                                   ///a const version of this object
+  /// 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
+  /// on this object was not previously demangled), demangle and cache the
+  /// name.
+  ConstString GetDemangledNameImpl(bool force,
+                                   const SymbolContext *sc = nullptr) const;
+
+  /// The mangled version of the name.
+  ConstString m_mangled;
+
+  /// Mutable so we can get it on demand with
+  /// a const version of this object.
+  mutable ConstString m_demangled;
 };
 
 Stream &operator<<(Stream &s, const Mangled &obj);

lldb/source/Core/Mangled.cpp

@@ -274,81 +274,91 @@ bool Mangled::GetRichManglingInfo(RichManglingContext &context,
   llvm_unreachable("Fully covered switch above!");
 }
 
+ConstString Mangled::GetDemangledName( // BEGIN SWIFT
+    const SymbolContext *sc
+    // END SWIFT
+) const {
+  return GetDemangledNameImpl(/*force=*/false, sc);
+}
+
 // 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
 // supplied to this object, or until the end of the object's lifetime.
-ConstString Mangled::GetDemangledName(// BEGIN SWIFT
-                                      const SymbolContext *sc
-                                      // END SWIFT
-                                      ) const {
-  // Check to make sure we have a valid mangled name and that we haven't
-  // already decoded our mangled name.
-  if (m_mangled && m_demangled.IsNull()) {
-    // Don't bother running anything that isn't mangled
-    const char *mangled_name = m_mangled.GetCString();
-    ManglingScheme mangling_scheme =
-        GetManglingScheme(m_mangled.GetStringRef());
-    if (mangling_scheme != eManglingSchemeNone &&
-        !m_mangled.GetMangledCounterpart(m_demangled)) {
-      // We didn't already mangle this name, demangle it and if all goes well
-      // add it to our map.
-      char *demangled_name = nullptr;
-      switch (mangling_scheme) {
-      case eManglingSchemeMSVC:
-        demangled_name = GetMSVCDemangledStr(mangled_name);
-        break;
-      case eManglingSchemeItanium: {
-        demangled_name = GetItaniumDemangledStr(mangled_name);
-        break;
-      }
-      case eManglingSchemeRustV0:
-        demangled_name = GetRustV0DemangledStr(m_mangled);
-        break;
-      case eManglingSchemeD:
-        demangled_name = GetDLangDemangledStr(m_mangled);
-        break;
-      case eManglingSchemeSwift:
-        // Demangling a swift name requires the swift compiler. This is
-        // explicitly unsupported on llvm.org.
+ConstString Mangled::GetDemangledNameImpl(bool force, // BEGIN SWIFT
+                                          const SymbolContext *sc
+                                          // END SWIFT
+) const {
+  if (!m_mangled)
+    return m_demangled;
+
+  // Re-use previously demangled names.
+  if (!force && !m_demangled.IsNull())
+    return m_demangled;
+
+  if (!force && m_mangled.GetMangledCounterpart(m_demangled) &&
+      !m_demangled.IsNull())
+    return m_demangled;
+
+  // We didn't already mangle this name, demangle it and if all goes well
+  // add it to our map.
+  char *demangled_name = nullptr;
+  switch (GetManglingScheme(m_mangled.GetStringRef())) {
+  case eManglingSchemeMSVC:
+    demangled_name = GetMSVCDemangledStr(m_mangled);
+    break;
+  case eManglingSchemeItanium: {
+    demangled_name = GetItaniumDemangledStr(m_mangled.GetCString());
+    break;
+  }
+  case eManglingSchemeRustV0:
+    demangled_name = GetRustV0DemangledStr(m_mangled);
+    break;
+  case eManglingSchemeD:
+    demangled_name = GetDLangDemangledStr(m_mangled);
+    break;
+  case eManglingSchemeSwift:
+    // Demangling a swift name requires the swift compiler. This is
+    // explicitly unsupported on llvm.org.
 #ifdef LLDB_ENABLE_SWIFT
-      {
-        Log *log = GetLog(LLDBLog::Demangle);
-        LLDB_LOGF(log, "demangle swift: %s", mangled_name);
-        std::string demangled(SwiftLanguageRuntime::DemangleSymbolAsString(
-            mangled_name, SwiftLanguageRuntime::eTypeName, sc));
-        // Don't cache the demangled name the function isn't available yet.
-        if (!sc || !sc->function) {
-          LLDB_LOGF(log, "demangle swift: %s -> \"%s\" (not cached)",
-                    mangled_name, demangled.c_str());
-          return ConstString(demangled);
-        }
-        if (demangled.empty()) {
-          LLDB_LOGF(log, "demangle swift: %s -> error: failed to demangle",
-                    mangled_name);
-        } else {
-          LLDB_LOGF(log, "demangle swift: %s -> \"%s\"", mangled_name,
-                    demangled.c_str());
-          m_demangled.SetStringWithMangledCounterpart(demangled, m_mangled);
-        }
-        return m_demangled;
-      }
-#endif // LLDB_ENABLE_SWIFT
-      break;
-      case eManglingSchemeNone:
-        llvm_unreachable("eManglingSchemeNone was handled already");
-      }
-      if (demangled_name) {
-        m_demangled.SetStringWithMangledCounterpart(
-            llvm::StringRef(demangled_name), m_mangled);
-        free(demangled_name);
-      }
+  {
+    const char *mangled_name = m_mangled.GetCString();
+    Log *log = GetLog(LLDBLog::Demangle);
+    LLDB_LOGF(log, "demangle swift: %s", mangled_name);
+    std::string demangled(SwiftLanguageRuntime::DemangleSymbolAsString(
+        mangled_name, SwiftLanguageRuntime::eTypeName, sc));
+    // Don't cache the demangled name the function isn't available yet.
+    if (!sc || !sc->function) {
+      LLDB_LOGF(log, "demangle swift: %s -> \"%s\" (not cached)", mangled_name,
+                demangled.c_str());
+      return ConstString(demangled);
     }
-    if (m_demangled.IsNull()) {
-      // Set the demangled string to the empty string to indicate we tried to
-      // parse it once and failed.
-      m_demangled.SetCString("");
+    if (demangled.empty()) {
+      LLDB_LOGF(log, "demangle swift: %s -> error: failed to demangle",
+                mangled_name);
+    } else {
+      LLDB_LOGF(log, "demangle swift: %s -> \"%s\"", mangled_name,
+                demangled.c_str());
+      m_demangled.SetStringWithMangledCounterpart(demangled, m_mangled);
     }
+    return m_demangled;
+  }
+#endif // LLDB_ENABLE_SWIFT
+  break;
+  case eManglingSchemeNone:
+    // Don't bother demangling anything that isn't mangled.
+    break;
+  }
+
+  if (demangled_name) {
+    m_demangled.SetStringWithMangledCounterpart(demangled_name, m_mangled);
+    free(demangled_name);
+  }
+
+  if (m_demangled.IsNull()) {
+    // Set the demangled string to the empty string to indicate we tried to
+    // parse it once and failed.
+    m_demangled.SetCString("");
   }
 
   return m_demangled;