Fix mangling for placeholder return types

Author: MaxEW707

llvm/include/llvm/Demangle/MicrosoftDemangle.h

@@ -173,6 +173,7 @@ class Demangler {
   TypeNode *demangleType(std::string_view &MangledName,
                          QualifierMangleMode QMM);
   PrimitiveTypeNode *demanglePrimitiveType(std::string_view &MangledName);
+  PlaceholderTypeNode *demanglePlaceholderType(std::string_view &MangledName);
   CustomTypeNode *demangleCustomType(std::string_view &MangledName);
   TagTypeNode *demangleClassType(std::string_view &MangledName);
   PointerTypeNode *demanglePointerType(std::string_view &MangledName);

llvm/include/llvm/Demangle/MicrosoftDemangleNodes.h

@@ -106,6 +106,11 @@ enum class PrimitiveKind {
   Nullptr,
 };
 
+enum class PlaceholderKind {
+  Auto,
+  DecltypeAuto,
+};
+
 enum class CharKind {
   Char,
   Char16,
@@ -251,7 +256,8 @@ enum class NodeKind {
   LocalStaticGuardVariable,
   FunctionSymbol,
   VariableSymbol,
-  SpecialTableSymbol
+  SpecialTableSymbol,
+  PlaceholderType,
 };
 
 struct Node {
@@ -270,6 +276,7 @@ struct Node {
 
 struct TypeNode;
 struct PrimitiveTypeNode;
+struct PlaceholderTypeNode;
 struct FunctionSignatureNode;
 struct IdentifierNode;
 struct NamedIdentifierNode;
@@ -318,6 +325,16 @@ struct PrimitiveTypeNode : public TypeNode {
   PrimitiveKind PrimKind;
 };
 
+struct PlaceholderTypeNode : public TypeNode {
+  explicit PlaceholderTypeNode(PlaceholderKind K)
+      : TypeNode(NodeKind::PlaceholderType), PlaceholderKind(K) {}
+
+  void outputPre(OutputBuffer &OB, OutputFlags Flags) const override;
+  void outputPost(OutputBuffer &OB, OutputFlags Flags) const override {}
+
+  PlaceholderKind PlaceholderKind;
+};
+
 struct FunctionSignatureNode : public TypeNode {
   explicit FunctionSignatureNode(NodeKind K) : TypeNode(K) {}
   FunctionSignatureNode() : TypeNode(NodeKind::FunctionSignature) {}

llvm/lib/Demangle/MicrosoftDemangle.cpp

@@ -241,6 +241,11 @@ static bool isFunctionType(std::string_view S) {
          llvm::itanium_demangle::starts_with(S, "$$A6");
 }
 
+static bool isPlaceholderType(std::string_view S) {
+  return llvm::itanium_demangle::starts_with(S, "_P") ||
+         llvm::itanium_demangle::starts_with(S, "_T");
+}
+
 static FunctionRefQualifier
 demangleFunctionRefQualifier(std::string_view &MangledName) {
   if (consumeFront(MangledName, 'G'))
@@ -1865,6 +1870,8 @@ TypeNode *Demangler::demangleType(std::string_view &MangledName,
     }
   } else if (isCustomType(MangledName)) {
     Ty = demangleCustomType(MangledName);
+  } else if (isPlaceholderType(MangledName)) {
+    Ty = demanglePlaceholderType(MangledName);
   } else {
     Ty = demanglePrimitiveType(MangledName);
   }
@@ -1978,6 +1985,23 @@ CustomTypeNode *Demangler::demangleCustomType(std::string_view &MangledName) {
   return CTN;
 }
 
+PlaceholderTypeNode *
+Demangler::demanglePlaceholderType(std::string_view &MangledName) {
+  assert(MangledName.front() == '_');
+
+  MangledName.remove_prefix(1);
+  const char F = MangledName.front();
+  MangledName.remove_prefix(1);
+  switch (F) {
+  case 'P':
+    return Arena.alloc<PlaceholderTypeNode>(PlaceholderKind::Auto);
+  case 'T':
+    return Arena.alloc<PlaceholderTypeNode>(PlaceholderKind::DecltypeAuto);
+  }
+  Error = true;
+  return nullptr;
+}
+
 // Reads a primitive type.
 PrimitiveTypeNode *
 Demangler::demanglePrimitiveType(std::string_view &MangledName) {

llvm/lib/Demangle/MicrosoftDemangleNodes.cpp

@@ -153,6 +153,14 @@ void PrimitiveTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const {
   outputQualifiers(OB, Quals, true, false);
 }
 
+void PlaceholderTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const {
+  switch (PlaceholderKind) {
+    OUTPUT_ENUM_CLASS_VALUE(PlaceholderKind, Auto, "auto");
+    OUTPUT_ENUM_CLASS_VALUE(PlaceholderKind, DecltypeAuto, "decltype(auto)");
+  };
+  outputQualifiers(OB, Quals, true, false);
+}
+
 void NodeArrayNode::output(OutputBuffer &OB, OutputFlags Flags) const {
   output(OB, Flags, ", ");
 }

llvm/test/Demangle/ms-placeholder-return-type.test

@@ -0,0 +1,18 @@
+; RUN: llvm-undname < %s | FileCheck %s
+
+; CHECK-NOT: Invalid mangled name
+
+?TestNonTemplateAuto@@YA@XZ
+; CHECK: __cdecl TestNonTemplateAuto(void)
+
+??$AutoT@X@@YA?A_PXZ
+; CHECK: auto __cdecl AutoT<void>(void)
+
+??$AutoT@X@@YA?B_PXZ
+; CHECK: auto const __cdecl AutoT<void>(void)
+
+??$AutoT@X@@YA?A_TXZ
+; CHECK: decltype(auto) __cdecl AutoT<void>(void)
+
+??$AutoT@X@@YA?B_TXZ
+; CHECK: decltype(auto) const __cdecl AutoT<void>(void)