[Demangle] Support demangling Swift calling convention in MS demangler.

[varungandhi-apple]

Summary

Previously, Clang was able to mangle the Swift calling
convention but 'MicrosoftDemangle.cpp' was not able to demangle it.

[compnerd]

Perhaps @rnk has any thoughts, but this seems very straightforward.

Thanks for fixing this!

llvm/test/Demangle/ms-mangle.test

342

Would be nice if we can have a space after the attribute in the printed output.

[varungandhi-apple]

Add extra space for better readability, as suggested by @compnerd.

[varungandhi-apple]

I've fixed this by including an additional space in the string instead of using a method like outputSpaceIfNecessary; (1) that method doesn't work as it is and I think changing it for this purpose is not appropriate and (2) we probably want the space there unconditionally anyways.

clang/lib/AST/MicrosoftMangle.cpp

void MicrosoftCXXNameMangler::mangleCallingConvention(CallingConv CC) {
   //                      ::= D # __export __pascal
   //                      ::= E # __thiscall
   //                      ::= F # __export __thiscall
   //                      ::= G # __stdcall
   //                      ::= H # __export __stdcall
   //                      ::= I # __fastcall
   //                      ::= J # __export __fastcall
   //                      ::= Q # __vectorcall
+  //                      ::= S # __attribute__((__swiftcall__)) // Clang-only
   //                      ::= w # __regcall
   // The 'export' calling conventions are from a bygone era
   // (*cough*Win16*cough*) when functions were declared for export with
   // that keyword. (It didn't actually export them, it just made them so
   // that they could be in a DLL and somebody from another module could call
   // them.)
 
   switch (CC) {

llvm/include/llvm/Demangle/MicrosoftDemangleNodes.h

enum class CallingConv : uint8_t {
   Pascal,
   Thiscall,
   Stdcall,
   Fastcall,
   Clrcall,
   Eabi,
   Vectorcall,
   Regcall,
+  Swift, // Clang-only
 };
 
 enum class ReferenceKind : uint8_t { None, LValueRef, RValueRef };
 
 enum OutputFlags {
   OF_Default = 0,
   OF_NoCallingConvention = 1,
   OF_NoTagSpecifier = 2,

llvm/lib/Demangle/MicrosoftDemangle.cpp

CallingConv Demangler::demangleCallingConvention(StringView &MangledName) {
   case 'M':
   case 'N':
     return CallingConv::Clrcall;
   case 'O':
   case 'P':
     return CallingConv::Eabi;
   case 'Q':
     return CallingConv::Vectorcall;
+  case 'S':
+    return CallingConv::Swift;
   }
 
   return CallingConv::None;
 }
 
 StorageClass Demangler::demangleVariableStorageClass(StringView &MangledName) {
   assert(MangledName.front() >= '0' && MangledName.front() <= '4');
 

llvm/lib/Demangle/MicrosoftDemangleNodes.cpp

case CallingConv::Eabi:
     OS << "__eabi";
     break;
   case CallingConv::Vectorcall:
     OS << "__vectorcall";
     break;
   case CallingConv::Clrcall:
     OS << "__clrcall";
     break;
+  case CallingConv::Swift:
+    OS << "__attribute__((__swiftcall__))";
+    break;
   default:
     break;
   }
 }
 
 std::string Node::toString(OutputFlags Flags) const {
   OutputStream OS;
   initializeOutputStream(nullptr, nullptr, OS, 1024);

llvm/test/Demangle/ms-mangle.test

 ; CHECK: static void __cdecl TypedefNewDelete::operator delete(void *)
 
 ??_VTypedefNewDelete@@SAXPAX@Z
 ; CHECK: static void __cdecl TypedefNewDelete::operator delete[](void *)
 
 ?vector_func@@YQXXZ
 ; CHECK: void __vectorcall vector_func(void)
 
+?swift_func@@YSXXZ
+; CHECK: void __attribute__((__swiftcall__))swift_func(void)
+
 ??$fn_tmpl@$1?extern_c_func@@YAXXZ@@YAXXZ
 ; CHECK: void __cdecl fn_tmpl<&void __cdecl extern_c_func(void)>(void)
 
 ?overloaded_fn@@$$J0YAXXZ
 ; CHECK: extern "C" void __cdecl overloaded_fn(void)
 
 ?f@UnnamedType@@YAXQAPAU<unnamed-type-T1>@S@1@@Z
 ; CHECK: void __cdecl UnnamedType::f(struct UnnamedType::S::<unnamed-type-T1> **const)