Add support for demangling msvc's noexcept types to llvm-undname

[zahen]

Summary

msvc under C++17 mangles noexcept functions used as types (function parameters, template types) with "_E" instead of "Z" indicating the function is noexcept.

[rnk]

lgtm

[zahen]

Same as the corresponding mangling patch, I'd appreciate someone else landing this since I don't have check-in permission.

[rnk]

Oops, too many Zacharies. I mistook you for him (only in this patch, not the other one). He has more ownership over this code, so I will let him approve it.

[zturner]

lgtm. I'm technically on vacation so rnk@ might be able to commit it sooner than I can, but if he doesn't, then I'll commit it when I find some spare cycles. Thanks for fixing this!

[zahen]

In D55769#1333778, @zturner wrote:

lgtm. I'm technically on vacation so rnk@ might be able to commit it sooner than I can, but if he doesn't, then I'll commit it when I find some spare cycles. Thanks for fixing this!

Hi @zturner, can you please commit this when you have a chance?

[kristina]

In D55769#1350029, @zahen wrote:

In D55769#1333778, @zturner wrote:

lgtm. I'm technically on vacation so rnk@ might be able to commit it sooner than I can, but if he doesn't, then I'll commit it when I find some spare cycles. Thanks for fixing this!

Hi @zturner, can you please commit this when you have a chance?

I don't mind doing it if there are no objections, as Zachary has signed off on it (may have to wait a bit, I'll run the tests with this applied first).

llvm/trunk/include/llvm/Demangle/MicrosoftDemangle.h

private:
   EncodedStringLiteralNode *demangleStringLiteral(StringView &MangledName);
   FunctionSymbolNode *demangleVcallThunkNode(StringView &MangledName);
 
   StringView demangleSimpleString(StringView &MangledName, bool Memorize);
 
   FuncClass demangleFunctionClass(StringView &MangledName);
   CallingConv demangleCallingConvention(StringView &MangledName);
   StorageClass demangleVariableStorageClass(StringView &MangledName);
-  void demangleThrowSpecification(StringView &MangledName);
+  bool demangleThrowSpecification(StringView &MangledName);
   wchar_t demangleWcharLiteral(StringView &MangledName);
   uint8_t demangleCharLiteral(StringView &MangledName);
 
   std::pair<Qualifiers, bool> demangleQualifiers(StringView &MangledName);
 
   // Memory allocator.
   ArenaAllocator Arena;
 

llvm/trunk/include/llvm/Demangle/MicrosoftDemangleNodes.h

struct FunctionSignatureNode : public TypeNode {
   // The return type of the function.
   TypeNode *ReturnType = nullptr;
 
   // True if this is a C-style ... varargs function.
   bool IsVariadic = false;
 
   // Function parameters
   NodeArrayNode *Params = nullptr;
+
+  // True if the function type is noexcept
+  bool IsNoexcept = false;
 };
 
 struct IdentifierNode : public Node {
   explicit IdentifierNode(NodeKind K) : Node(K) {}
 
   NodeArrayNode *TemplateParams = nullptr;
 
 protected:
struct FunctionSymbolNode : public SymbolNode {
 
   FunctionSignatureNode *Signature = nullptr;
 };
 
 } // namespace ms_demangle
 } // namespace llvm
 
 #endif
 No newline at end of file

llvm/trunk/lib/Demangle/MicrosoftDemangle.cpp

TypeNode *Demangler::demangleType(StringView &MangledName,
   }
 
   if (!Ty || Error)
     return Ty;
   Ty->Quals = Qualifiers(Ty->Quals | Quals);
   return Ty;
 }
 
-void Demangler::demangleThrowSpecification(StringView &MangledName) {
+bool Demangler::demangleThrowSpecification(StringView &MangledName) {
+  if (MangledName.consumeFront("_E"))
+    return true;
   if (MangledName.consumeFront('Z'))
-    return;
+    return false;
 
   Error = true;
+  return false;
 }
 
 FunctionSignatureNode *Demangler::demangleFunctionType(StringView &MangledName,
                                                        bool HasThisQuals) {
   FunctionSignatureNode *FTy = Arena.alloc<FunctionSignatureNode>();
 
   if (HasThisQuals) {
     FTy->Quals = demanglePointerExtQualifiers(MangledName);
     FTy->RefQualifier = demangleFunctionRefQualifier(MangledName);
     FTy->Quals = Qualifiers(FTy->Quals | demangleQualifiers(MangledName).first);
   }
 
   // Fields that appear on both member and non-member functions.
   FTy->CallConvention = demangleCallingConvention(MangledName);
 
   // <return-type> ::= <type>
   //               ::= @ # structors (they have no declared return type)
   bool IsStructor = MangledName.consumeFront('@');
   if (!IsStructor)
     FTy->ReturnType = demangleType(MangledName, QualifierMangleMode::Result);
 
   FTy->Params = demangleFunctionParameterList(MangledName);
 
-  demangleThrowSpecification(MangledName);
+  FTy->IsNoexcept = demangleThrowSpecification(MangledName);
 
   return FTy;
 }
 
 FunctionSymbolNode *
 Demangler::demangleFunctionEncoding(StringView &MangledName) {
   FuncClass ExtraFlags = FC_None;
   if (MangledName.consumeFront("$$J0"))

llvm/trunk/lib/Demangle/MicrosoftDemangleNodes.cpp

if (Quals & Q_Const)
     OS << " const";
   if (Quals & Q_Volatile)
     OS << " volatile";
   if (Quals & Q_Restrict)
     OS << " __restrict";
   if (Quals & Q_Unaligned)
     OS << " __unaligned";
 
+  if (IsNoexcept)
+    OS << " noexcept";
+
   if (RefQualifier == FunctionRefQualifier::Reference)
     OS << " &";
   else if (RefQualifier == FunctionRefQualifier::RValueReference)
     OS << " &&";
 
   if (ReturnType)
     ReturnType->outputPost(OS, Flags);
 }

llvm/trunk/test/Demangle/ms-cxx17-noexcept.test

+; RUN: llvm-undname < %s | FileCheck %s
+
+; CHECK-NOT: Invalid mangled name
+
+?nochange@@YAXXZ
+; CHECK: void __cdecl nochange(void)
+
+?a@@YAXP6AHXZ@Z
+; CHECK: void __cdecl a(int (__cdecl *)(void))
+?a@@YAXP6AHX_E@Z
+; CHECK: void __cdecl a(int (__cdecl *)(void) noexcept)
+
+?b@@YAXP6AHXZ@Z
+; CHECK: void __cdecl b(int (__cdecl *)(void))
+
+?c@@YAXP6AHXZ@Z
+; CHECK: void __cdecl c(int (__cdecl *)(void))
+?c@@YAXP6AHX_E@Z
+; CHECK: void __cdecl c(int (__cdecl *)(void) noexcept)
+
+?ee@?$e@$$A6AXXZ@@EEAAXXZ
+; CHECK: private: virtual void __cdecl e<void __cdecl(void)>::ee(void)
+
+?ee@?$e@$$A6AXX_E@@EEAAXXZ
+; CHECK: private: virtual void __cdecl e<void __cdecl(void) noexcept>::ee(void)