[lldb] Remove cache in get_demangled_name_without_arguments

[teemperor]

Summary

This function has a single-value caching based on function local static variables.

This causes two problems:

• There is no synchronization, so this function randomly returns the demangled name of other functions that are demangled at the same time.
• The 1-element cache is not very effective (the cache rate is around 0% when running the LLDB test suite that calls this function around 30k times).

I would propose just removing it.

To prevent anyone else the git archeology: the static result variables were originally
added as this returned a ConstString reference, but that has since been changed
so that this returns by value.

[teemperor]

lldb/source/Core/Mangled.cpp

38

I changed the name to reflect the code style. I'll do the same for the function above as a NFC follow up.

[JDevlieghere]

LGTM

[shafik]

was there a bug that inspired this?

[teemperor]

In D103107#2780769, @shafik wrote:

was there a bug that inspired this?

Nope, the code just looked bogus when I scrolled over it while looking for something else.

lldb/source/Core/Mangled.cpp

 //===-- Mangled.cpp -------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/Mangled.h"
 
 #include "lldb/Core/RichManglingContext.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Logging.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/lldb-enumerations.h"

 #include <stdlib.h>
 #include <string.h>
 using namespace lldb_private;
 
 static inline bool cstring_is_mangled(llvm::StringRef s) {
   return Mangled::GetManglingScheme(s) != Mangled::eManglingSchemeNone;
 }
 
-static ConstString 
-get_demangled_name_without_arguments(ConstString mangled,
+static ConstString GetDemangledNameWithoutArguments(ConstString mangled,
                                                     ConstString demangled) {
-  // This pair is <mangled name, demangled name without function arguments>
-  static std::pair<ConstString, ConstString>
-      g_most_recent_mangled_to_name_sans_args;
-
-  // Need to have the mangled & demangled names we're currently examining as
-  // statics so we can return a const ref to them at the end of the func if we
-  // don't have anything better.
-  static ConstString g_last_mangled;
-  static ConstString g_last_demangled;
-
-  if (mangled && g_most_recent_mangled_to_name_sans_args.first == mangled) {
-    return g_most_recent_mangled_to_name_sans_args.second;
-  }
-
-  g_last_demangled = demangled;
-  g_last_mangled = mangled;
-
   const char *mangled_name_cstr = mangled.GetCString();
 
   if (demangled && mangled_name_cstr && mangled_name_cstr[0]) {
     if (mangled_name_cstr[0] == '_' && mangled_name_cstr[1] == 'Z' &&
         (mangled_name_cstr[2] != 'T' && // avoid virtual table, VTT structure,
                                         // typeinfo structure, and typeinfo
                                         // mangled_name
          mangled_name_cstr[2] != 'G' && // avoid guard variables
          mangled_name_cstr[2] != 'Z')) // named local entities (if we eventually
                                        // handle eSymbolTypeData, we will want
                                        // this back)
     {
       CPlusPlusLanguage::MethodName cxx_method(demangled);
       if (!cxx_method.GetBasename().empty()) {
         std::string shortname;
         if (!cxx_method.GetContext().empty())
           shortname = cxx_method.GetContext().str() + "::";
         shortname += cxx_method.GetBasename().str();
-        ConstString result(shortname.c_str());
-        g_most_recent_mangled_to_name_sans_args.first = mangled;
-        g_most_recent_mangled_to_name_sans_args.second = result;
-        return g_most_recent_mangled_to_name_sans_args.second;
+        return ConstString(shortname);
       }
     }
   }
-
   if (demangled)
-    return g_last_demangled;
-  return g_last_mangled;
+    return demangled;
+  return mangled;
 }
 
 #pragma mark Mangled
 
 Mangled::ManglingScheme Mangled::GetManglingScheme(llvm::StringRef const name) {
   if (name.empty())
     return Mangled::eManglingSchemeNone;
 

 // Get the demangled name if there is one, else return the mangled name.
 ConstString Mangled::GetName(Mangled::NamePreference preference) const {
   if (preference == ePreferMangled && m_mangled)
     return m_mangled;
 
   ConstString demangled = GetDemangledName();
 
   if (preference == ePreferDemangledWithoutArguments) {
-    return get_demangled_name_without_arguments(m_mangled, demangled);
+    return GetDemangledNameWithoutArguments(m_mangled, demangled);
   }
   if (preference == ePreferDemangled) {
     // Call the accessor to make sure we get a demangled name in case it hasn't
     // been demangled yet...
     if (demangled)
       return demangled;
     return m_mangled;
   }