Merge pull request #4883 from adrian-prantl/92571418

Adapt Swift mangled name handling to upstream changes

Author: adrian-prantl

lldb/include/lldb/Core/Mangled.h

@@ -44,7 +44,10 @@ class Mangled {
     eManglingSchemeMSVC,
     eManglingSchemeItanium,
     eManglingSchemeRustV0,
-    eManglingSchemeD
+    eManglingSchemeD,
+#ifdef LLDB_ENABLE_SWIFT
+    eManglingSchemeSwift
+#endif // LLDB_ENABLE_SWIFT
   };
 
   /// Default constructor.

lldb/source/Core/Mangled.cpp

@@ -41,11 +41,7 @@
 using namespace lldb_private;
 
 static inline bool cstring_is_mangled(llvm::StringRef s) {
-  return Mangled::GetManglingScheme(s) != Mangled::eManglingSchemeNone
-#ifdef LLDB_ENABLE_SWIFT
-         || SwiftLanguageRuntime::IsSwiftMangledName(s)
-#endif // LLDB_ENABLE_SWIFT
-         ;
+  return Mangled::GetManglingScheme(s) != Mangled::eManglingSchemeNone;
 }
 
 // BEGIN SWIFT
@@ -91,6 +87,11 @@ Mangled::ManglingScheme Mangled::GetManglingScheme(llvm::StringRef const name) {
   if (name.startswith("___Z"))
     return Mangled::eManglingSchemeItanium;
 
+#ifdef LLDB_ENABLE_SWIFT
+  if (SwiftLanguageRuntime::IsSwiftMangledName(name))
+    return Mangled::eManglingSchemeSwift;
+#endif // LLDB_ENABLE_SWIFT
+  
   return Mangled::eManglingSchemeNone;
 }
 
@@ -278,6 +279,9 @@ bool Mangled::GetRichManglingInfo(RichManglingContext &context,
 
   case eManglingSchemeRustV0:
   case eManglingSchemeD:
+#ifdef LLDB_ENABLE_SWIFT
+  case eManglingSchemeSwift:
+#endif
     // Rich demangling scheme is not supported
     return false;
   }
@@ -318,6 +322,29 @@ ConstString Mangled::GetDemangledName(// BEGIN SWIFT
       case eManglingSchemeD:
         demangled_name = GetDLangDemangledStr(mangled_name);
         break;
+#ifdef LLDB_ENABLE_SWIFT
+      case eManglingSchemeSwift: {
+        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
       case eManglingSchemeNone:
         llvm_unreachable("eManglingSchemeNone was handled already");
       }
@@ -327,31 +354,6 @@ ConstString Mangled::GetDemangledName(// BEGIN SWIFT
         free(demangled_name);
       }
     }
-#ifdef LLDB_ENABLE_SWIFT
-    else if (mangling_scheme == eManglingSchemeNone &&
-               !m_mangled.GetMangledCounterpart(m_demangled) &&
-               SwiftLanguageRuntime::IsSwiftMangledName(m_mangled.GetStringRef())) {
-      Log *log = GetLog(LLDBLog::Demangle);
-      if (log)
-        log->Printf("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)
-        return ConstString(demangled);
-      if (!demangled.empty()) {
-        m_demangled.SetStringWithMangledCounterpart(demangled,
-						    m_mangled);
-        if (log)
-          log->Printf("demangle swift: %s -> \"%s\"", mangled_name,
-                      demangled.c_str());
-      } else {
-        if (log)
-          log->Printf("demangle swift: %s -> error: failed to demangle",
-                      mangled_name);
-      }
-    }
-#endif // LLDB_ENABLE_SWIFT
     if (m_demangled.IsNull()) {
       // Set the demangled string to the empty string to indicate we tried to
       // parse it once and failed.

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

@@ -269,15 +269,19 @@ std::string CPlusPlusLanguage::MethodName::GetScopeQualifiedName() {
 }
 
 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
-
   Mangled::ManglingScheme scheme = Mangled::GetManglingScheme(name);
-
-  if (scheme == Mangled::eManglingSchemeNone)
+  switch (scheme) {
+  case Mangled::eManglingSchemeMSVC:
+  case Mangled::eManglingSchemeItanium:
+    return true;
+  case Mangled::eManglingSchemeNone:
+  case Mangled::eManglingSchemeRustV0:
+  case Mangled::eManglingSchemeD:
+#ifdef LLDB_ENABLE_SWIFT
+  case Mangled::eManglingSchemeSwift:
+#endif
     return false;
-
-  return true;
+  }
 }
 
 bool CPlusPlusLanguage::ExtractContextAndIdentifier(

lldb/source/Symbol/Symtab.cpp

@@ -263,6 +263,10 @@ static bool lldb_skip_name(llvm::StringRef mangled,
   case Mangled::eManglingSchemeD:
     return false;
 
+#ifdef LLDB_ENABLE_SWIFT
+  case Mangled::eManglingSchemeSwift:
+    // This is handled separately.
+#endif // LLDB_ENABLE_SWIFT
   // Don't try and demangle things we can't categorize.
   case Mangled::eManglingSchemeNone:
     return true;