Fix handling for the clang name mangling extension for block invocations

[shafik]

Summary

clang has a mangling extension for block invocations and currently lldb does not handle it correctly.

[jingham]

lldb/source/Core/Mangled.cpp

99

StringRef has a startswith. That might be easier to read.

[aprantl]

lldb/include/lldb/Core/Mangled.h

264

Doxygen comment?

lldb/source/Core/Mangled.cpp

99

Agreed. There should be no performance penalty for using startswith over this in an optimized build.

102

Is ___Z really only used for blocks or is it used for other clang extensions, too?

104

Just FYI, this will create a merge conflict with swift-lldb. You might want to think about how to resolve it ahead of committing.

106

You don't need to fix this all at once, but I think it would be even better if this function did something like

for each language plugin { 
  if (mangling_scheme = plugin.isMangledName(...)
    ...
}

I.e., the plugins should be the ones that know about the mangling details.

310

If it's equivalent I'd find
ManglingScheme mangling_scheme = GetManglingScheme(m_mangled.GetStringRef());
easier to read.

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h

104

That's a good idea anyway :-)

[shafik]

Updating based on comments

• Adding documentation
• using startswith(...)
• Updating initialization to use = instead of {}

[shafik]

lldb/source/Core/Mangled.cpp

99

Great catch!

102

This is solely for block invocations.

104

It does not look too bad.

106

There is an old comment akin to that in IsCPPMangledName. I did not want to stray too far off into refactoring in this PR.

[aprantl]

lldb/source/Core/Mangled.cpp

36

I was going to say, the function name doesn't make sense any more, but really we probably don't need this function at all, right?

106

I think IsCPPMangledName should be called IsMangledName and every language plugin should define one. The fact that you forgot to make the same bugfix in CPlusPlusLanguage::IsCPPMangledName should be motivation enough to not implement the same functionality in two places :-)

[aprantl]

Let's do the refactoring in a follow-up commit.

lldb/include/lldb/Core/Mangled.h

public:
   ///     A filtering function for skipping entities based on name and mangling
   ///     scheme. This can be null if unused.
   ///
   /// \return
   ///     True on success, false otherwise.
   bool DemangleWithRichManglingInfo(RichManglingContext &context,
                                     SkipMangledNameFn *skip_mangled_name);
 
+  /// Try to identify the mangling scheme used.
+  /// \param[in] name
+  ///     The name we are attempting to identify the mangling scheme for.
+  ///
+  /// \return
+  ///     eManglingSchemeNone if no known mangling scheme could be identified
+  ///     for s, otherwise the enumerator for the mangling scheme detected.
+  static Mangled::ManglingScheme GetManglingScheme(llvm::StringRef const name);
+
 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
 };
 
 Stream &operator<<(Stream &s, const Mangled &obj);
 
 } // namespace lldb_private
 
 #endif // #if defined(__cplusplus)
 #endif // liblldb_Mangled_h_

lldb/source/Core/Mangled.cpp

 #include <mutex>
 #include <string>
 #include <utility>
 
 #include <stdlib.h>
 #include <string.h>
 using namespace lldb_private;
 
-static inline Mangled::ManglingScheme cstring_mangling_scheme(const char *s) {
-  if (s) {
-    if (s[0] == '?')
-      return Mangled::eManglingSchemeMSVC;
-    if (s[0] == '_' && s[1] == 'Z')
-      return Mangled::eManglingSchemeItanium;
-  }
-  return Mangled::eManglingSchemeNone;
-}
-
-static inline bool cstring_is_mangled(const char *s) {
-  return cstring_mangling_scheme(s) != Mangled::eManglingSchemeNone;
+static inline bool cstring_is_mangled(llvm::StringRef s) {
+  return Mangled::GetManglingScheme(s) != Mangled::eManglingSchemeNone;
 }
 
 static ConstString 
 get_demangled_name_without_arguments(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;
get_demangled_name_without_arguments(ConstString mangled,
 
   if (demangled)
     return g_last_demangled;
   return g_last_mangled;
 }
 
 #pragma mark Mangled
 
+Mangled::ManglingScheme Mangled::GetManglingScheme(llvm::StringRef const name) {
+  if (name.empty())
+    return Mangled::eManglingSchemeNone;
+
+  if (name.startswith("?"))
+    return Mangled::eManglingSchemeMSVC;
+
+  if (name.startswith("_Z"))
+    return Mangled::eManglingSchemeItanium;
+
+  // ___Z is a clang extension of block invocations
+  if (name.startswith("___Z"))
+    return Mangled::eManglingSchemeItanium;
+
+  return Mangled::eManglingSchemeNone;
+}
+
 Mangled::Mangled(ConstString s) : m_mangled(), m_demangled() {
   if (s)
     SetValue(s);
 }
 
 Mangled::Mangled(llvm::StringRef name) {
   if (!name.empty())
     SetValue(ConstString(name));
void Mangled::SetValue(ConstString s, bool mangled) {
   } else {
     m_demangled.Clear();
     m_mangled.Clear();
   }
 }
 
 void Mangled::SetValue(ConstString name) {
   if (name) {
-    if (cstring_is_mangled(name.GetCString())) {
+    if (cstring_is_mangled(name.GetStringRef())) {
       m_demangled.Clear();
       m_mangled = name;
     } else {
       m_demangled = name;
       m_mangled.Clear();
     }
   } else {
     m_demangled.Clear();
Timer scoped_timer(func_cat,
                      "Mangled::DemangleWithRichNameIndexInfo (m_mangled = %s)",
                      m_mangled.GetCString());
 
   // Others are not meant to arrive here. ObjC names or C's main() for example
   // have their names stored in m_demangled, while m_mangled is empty.
   assert(m_mangled);
 
   // Check whether or not we are interested in this name at all.
-  ManglingScheme scheme = cstring_mangling_scheme(m_mangled.GetCString());
+  ManglingScheme scheme = GetManglingScheme(m_mangled.GetStringRef());
   if (skip_mangled_name && skip_mangled_name(m_mangled.GetStringRef(), scheme))
     return false;
 
   switch (scheme) {
   case eManglingSchemeNone:
     // The current mangled_name_filter would allow llvm_unreachable here.
     return false;
 
Mangled::GetDemangledName(lldb::LanguageType language) const {
   if (m_mangled && m_demangled.IsNull()) {
     // We need to generate and cache the demangled name.
     static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
     Timer scoped_timer(func_cat, "Mangled::GetDemangledName (m_mangled = %s)",
                        m_mangled.GetCString());
 
     // Don't bother running anything that isn't mangled
     const char *mangled_name = m_mangled.GetCString();
-    ManglingScheme mangling_scheme{cstring_mangling_scheme(mangled_name)};
+    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);

 // We "guess" the language because we can't determine a symbol's language from
 // it's name.  For example, a Pascal symbol can be mangled using the C++
 // Itanium scheme, and defined in a compilation unit within the same module as
 // other C++ units.  In addition, different targets could have different ways
 // of mangling names from a given language, likewise the compilation units
 // within those targets.
 lldb::LanguageType Mangled::GuessLanguage() const {
   ConstString mangled = GetMangledName();
+
   if (mangled) {
     const char *mangled_name = mangled.GetCString();
     if (CPlusPlusLanguage::IsCPPMangledName(mangled_name))
       return lldb::eLanguageTypeC_plus_plus;
     else if (ObjCLanguage::IsPossibleObjCMethodName(mangled_name))
       return lldb::eLanguageTypeObjC;
   } else {
     // ObjC names aren't really mangled, so they won't necessarily be in the

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h

public:
   static void Initialize();
 
   static void Terminate();
 
   static lldb_private::Language *CreateInstance(lldb::LanguageType language);
 
   static lldb_private::ConstString GetPluginNameStatic();
 
-  static bool IsCPPMangledName(const char *name);
+  static bool IsCPPMangledName(llvm::StringRef name);
 
   // Extract C++ context and identifier from a string using heuristic matching
   // (as opposed to
   // CPlusPlusLanguage::MethodName which has to have a fully qualified C++ name
   // with parens and arguments.
   // If the name is a lone C identifier (e.g. C) or a qualified C identifier
   // (e.g. A::B::C) it will return true,
   // and identifier will be the identifier (C and C respectively) and the

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

 #include <functional>
 #include <memory>
 #include <mutex>
 #include <set>
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Demangle/ItaniumDemangle.h"
 
+#include "lldb/Core/Mangled.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/DataFormatters/CXXFunctionPointer.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/DataFormatters/VectorType.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
std::string CPlusPlusLanguage::MethodName::GetScopeQualifiedName() {
 
   std::string res;
   res += m_context;
   res += "::";
   res += m_basename;
   return res;
 }
 
-bool CPlusPlusLanguage::IsCPPMangledName(const char *name) {
+bool CPlusPlusLanguage::IsCPPMangledName(llvm::StringRef name) {
   // FIXME!! we should really run through all the known C++ Language plugins
   // and ask each one if this is a C++ mangled name
 
-  if (name == nullptr)
+  Mangled::ManglingScheme scheme = Mangled::GetManglingScheme(name);
+
+  if (scheme == Mangled::eManglingSchemeNone)
     return false;
 
-  // MSVC style mangling
-  if (name[0] == '?')
-    return true;
-
-  return (name[0] != '\0' && name[0] == '_' && name[1] == 'Z');
 }
 
 bool CPlusPlusLanguage::ExtractContextAndIdentifier(
     const char *name, llvm::StringRef &context, llvm::StringRef &identifier) {
   if (MSVCUndecoratedNameParser::IsMSVCUndecoratedName(name))
     return MSVCUndecoratedNameParser::ExtractContextAndIdentifier(name, context,
                                                                   identifier);
 

lldb/unittests/Core/MangledTest.cpp

TEST(MangledTest, ResultForValidName) {
   Mangled TheMangled(MangledName);
   ConstString TheDemangled =
       TheMangled.GetDemangledName(eLanguageTypeC_plus_plus);
 
   ConstString ExpectedResult("void a::b::c<int, int, int>(unsigned long)");
   EXPECT_STREQ(ExpectedResult.GetCString(), TheDemangled.GetCString());
 }
 
+TEST(MangledTest, ResultForBlockInvocation) {
+  ConstString MangledName("___Z1fU13block_pointerFviE_block_invoke");
+  Mangled TheMangled(MangledName);
+  ConstString TheDemangled =
+      TheMangled.GetDemangledName(eLanguageTypeC_plus_plus);
+
+  ConstString ExpectedResult(
+      "invocation function for block in f(void (int) block_pointer)");
+  EXPECT_STREQ(ExpectedResult.GetCString(), TheDemangled.GetCString());
+}
+
 TEST(MangledTest, EmptyForInvalidName) {
   ConstString MangledName("_ZN1a1b1cmxktpEEvm");
   Mangled TheMangled(MangledName);
   ConstString TheDemangled =
       TheMangled.GetDemangledName(eLanguageTypeC_plus_plus);
 
   EXPECT_STREQ("", TheDemangled.GetCString());
 }