[lldb] Add support for recognizing swift mangled names

[bulbazord]

Summary

Apple maintains a downstream fork of lldb in order to support swift
debugging. Much of that support is isolated to its own plugins, but some
of it is exposed in more generic code. I would like to take some of
the swift support we have downstream and move it upstream to llvm.org in
an effort to 1) reduce downstream maintenance burden, and 2) work
towards solidifying the process of adding new language support to lldb.

[JDevlieghere]

Given support for other languages like Rust and D, I think this is reasonable. LGTM.

[aprantl]

lldb/source/Core/Mangled.cpp

61

Feel free to completely ignore this, it's a pointless micro optimization.

I'm curious if it would be more efficient to write this as

switch (name[0]) {
  case '?':     return Mangled::eManglingSchemeMSVC;
  case '_': 
     switch(name[1]) {
        ...
     }
  case '$': 
     switch(name[1]) {
        ...
     }

or if it would actually be slower than the chain of "vector" comparisons we have right now?

[JDevlieghere]

lldb/source/Core/Mangled.cpp

61

I actually started writing a similar comment before discarding it. Even if this code is as hot as I expect it to be, I don't think it would outweigh the complexity and the potential for bugs. I really like how you can glance at the code and see the different mangling schemes and that's the first thing we'd lose. Anyway happy to be proven wrong too.

[fdeazeve]

lldb/source/Core/Mangled.cpp

61

Honestly the optimizer is pretty good at doing those, look at the IR: https://godbolt.org/z/PY3TeadbM

[aprantl]

lldb/source/Core/Mangled.cpp

61

Sounds good, let's leave it!

Just trolling now: should we use some crazy #ifdef magic to flip the order based on the host platform, such the ? comes first on windows and $ comes first on Darwin?

[JDevlieghere]

lldb/source/Core/Mangled.cpp

61

Did someone say tablegen?

[bulbazord]

lldb/source/Core/Mangled.cpp

61

As much as I love micro-optimizations, let's do all of that in a follow-up. ;)

lldb/include/lldb/Core/Mangled.h

enum NamePreference {
     ePreferDemangledWithoutArguments
   };
 
   enum ManglingScheme {
     eManglingSchemeNone = 0,
     eManglingSchemeMSVC,
     eManglingSchemeItanium,
     eManglingSchemeRustV0,
-    eManglingSchemeD
+    eManglingSchemeD,
+    eManglingSchemeSwift,
   };
 
   /// Default constructor.
   ///
   /// Initialize with both mangled and demangled names empty.
   Mangled() = default;
 
   /// Construct with name.

lldb/source/Core/Mangled.cpp

Mangled::ManglingScheme Mangled::GetManglingScheme(llvm::StringRef const name) {
 
   if (name.startswith("_Z"))
     return Mangled::eManglingSchemeItanium;
 
   // ___Z is a clang extension of block invocations
   if (name.startswith("___Z"))
     return Mangled::eManglingSchemeItanium;
 
+  // Swift's older style of mangling used "_T" as a mangling prefix. This can
+  // lead to false positives with other symbols that just so happen to start
+  // with "_T". To minimize the chance of that happening, we only return true
+  // for select old-style swift mangled names. The known cases are ObjC classes
+  // and protocols. Classes are either prefixed with "_TtC" or "_TtGC".
+  // Protocols are prefixed with "_TtP".
+  if (name.startswith("_TtC") || name.startswith("_TtGC") ||
+      name.startswith("_TtP"))
+    return Mangled::eManglingSchemeSwift;
+
+  // Swift 4.2 used "$S" and "_$S".
+  // Swift 5 and onward uses "$s" and "_$s".
+  // Swift also uses "@__swiftmacro_" as a prefix for mangling filenames.
+  if (name.startswith("$S") || name.startswith("_$S") ||
+      name.startswith("$s") || name.startswith("_$s") ||
+      name.startswith("@__swiftmacro_"))
+    return Mangled::eManglingSchemeSwift;
+
   return Mangled::eManglingSchemeNone;
 }
 
 Mangled::Mangled(ConstString s) : m_mangled(), m_demangled() {
   if (s)
     SetValue(s);
 }
 
if (m_demangled.IsEmpty()) {
       // Demangled successfully, we can try and parse it with
       // CPlusPlusLanguage::MethodName.
       return context.FromCxxMethodName(m_demangled);
     }
   }
 
   case eManglingSchemeRustV0:
   case eManglingSchemeD:
+  case eManglingSchemeSwift:
     // Rich demangling scheme is not supported
     return false;
   }
   llvm_unreachable("Fully covered switch above!");
 }
 
 // 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
if (mangling_scheme != eManglingSchemeNone &&
         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.
+        break;
       case eManglingSchemeNone:
         llvm_unreachable("eManglingSchemeNone was handled already");
       }
       if (demangled_name) {
         m_demangled.SetStringWithMangledCounterpart(
             llvm::StringRef(demangled_name), m_mangled);
         free(demangled_name);
       }

lldb/unittests/Core/MangledTest.cpp

 TEST(MangledTest, EmptyForInvalidDLangName) {
   ConstString mangled_name("_DDD");
   Mangled the_mangled(mangled_name);
   ConstString the_demangled = the_mangled.GetDemangledName();
 
   EXPECT_STREQ("", the_demangled.GetCString());
 }
 
+TEST(MangledTest, RecognizeSwiftMangledNames) {
+  llvm::StringRef valid_swift_mangled_names[] = {
+      "_TtC4main7MyClass",   // Mangled objc class name
+      "_TtP4main3Foo_",      // Mangld objc protocol name
+      "$s4main3BarCACycfC",  // Mangled name
+      "_$s4main3BarCACycfC", // Mangled name with leading underscore
+      "$S4main3BarCACycfC",  // Older swift mangled name
+      "_$S4main3BarCACycfC", // Older swift mangled name
+                             // with leading underscore
+      // Mangled swift filename
+      "@__swiftmacro_4main16FunVariableNames9OptionSetfMm_.swift",
+  };
+
+  for (llvm::StringRef mangled : valid_swift_mangled_names)
+    EXPECT_EQ(Mangled::GetManglingScheme(mangled),
+              Mangled::eManglingSchemeSwift);
+}
+
 TEST(MangledTest, BoolConversionOperator) {
   {
     ConstString MangledName("_ZN1a1b1cIiiiEEvm");
     Mangled TheMangled(MangledName);
     EXPECT_EQ(true, bool(TheMangled));
     EXPECT_EQ(false, !TheMangled);
   }
   {