MS ABI: Mangle empty type parameter packs compatibly

[majnemer]

Summary

The MS mangling scheme apparently has separate manglings for type and
non-type parameter packs when they are empty. Add state to
TemplateArgument to track this.

[rnk]

I think we can do this by looking at the TemplateParmDecls. It's worth a shot, at least.

[majnemer]

Closed by commit rL214932 (authored by @majnemer).

include/clang/AST/TemplateBase.h

struct I {
     union {
       uint64_t VAL;          ///< Used to store the <= 64 bits integer value.
       const uint64_t *pVal;  ///< Used to store the >64 bits integer value.
     };
     void *Type;
   };
   struct A {
     unsigned Kind;
-    unsigned NumArgs;
+    unsigned NumArgs : 31;
+    unsigned IsNonType : 1;
     const TemplateArgument *Args;
   };
   struct TA {
     unsigned Kind;
     unsigned NumExpansions;
     void *Name;
   };
   struct TV {
TemplateArgument(Expr *E) {
     TypeOrValue.Kind = Expression;
     TypeOrValue.V = reinterpret_cast<uintptr_t>(E);
   }
 
   /// \brief Construct a template argument that is a template argument pack.
   ///
   /// We assume that storage for the template arguments provided
   /// outlives the TemplateArgument itself.
-  TemplateArgument(const TemplateArgument *Args, unsigned NumArgs) {
+  TemplateArgument(const TemplateArgument *Args, unsigned NumArgs,
+                   bool IsNonType) {
+    assert(NumArgs <= ((1U << 31) - 1) && "too many template args!");
     this->Args.Kind = Pack;
     this->Args.Args = Args;
     this->Args.NumArgs = NumArgs;
+    this->Args.IsNonType = IsNonType;
   }
 
-  static TemplateArgument getEmptyPack() {
-    return TemplateArgument((TemplateArgument*)nullptr, 0);
+  static TemplateArgument getEmptyPack(bool IsNonType) {
+    return TemplateArgument((TemplateArgument*)nullptr, 0, IsNonType);
   }
 
   /// \brief Create a new template argument pack by copying the given set of
   /// template arguments.
   static TemplateArgument CreatePackCopy(ASTContext &Context,
                                          const TemplateArgument *Args,
-                                         unsigned NumArgs);
-  
+                                         unsigned NumArgs, bool IsNonType);
   /// \brief Return the kind of stored template argument.
   ArgKind getKind() const { return (ArgKind)TypeOrValue.Kind; }
 
   /// \brief Determine whether this template argument has no value.
   bool isNull() const { return getKind() == Null; }
 
   /// \brief Whether this template argument is dependent on a template
   /// parameter such that its result can change from one instantiation to
public:
   }
 
   /// \brief Return the array of arguments in this template argument pack.
   ArrayRef<TemplateArgument> getPackAsArray() const {
     assert(getKind() == Pack);
     return ArrayRef<TemplateArgument>(Args.Args, Args.NumArgs);
   }
 
+  bool isPackNonType() const {
+    assert(getKind() == Pack);
+    return Args.IsNonType;
+  }
+
   /// \brief Determines whether two template arguments are superficially the
   /// same.
   bool structurallyEquals(const TemplateArgument &Other) const;
 
   /// \brief When the template argument is a pack expansion, returns
   /// the pattern of the pack expansion.
   TemplateArgument getPackExpansionPattern() const;
 

lib/AST/ASTContext.cpp

case TemplateArgument::Pack: {
       TemplateArgument *CanonArgs
         = new (*this) TemplateArgument[Arg.pack_size()];
       unsigned Idx = 0;
       for (TemplateArgument::pack_iterator A = Arg.pack_begin(),
                                         AEnd = Arg.pack_end();
            A != AEnd; (void)++A, ++Idx)
         CanonArgs[Idx] = getCanonicalTemplateArgument(*A);
 
-      return TemplateArgument(CanonArgs, Arg.pack_size());
+      return TemplateArgument(CanonArgs, Arg.pack_size(), Arg.isPackNonType());
     }
   }
 
   // Silence GCC warning
   llvm_unreachable("Unhandled template argument kind");
 }
 
 NestedNameSpecifier *

lib/AST/ASTImporter.cpp

case TemplateArgument::Pack: {
     SmallVector<TemplateArgument, 2> ToPack;
     ToPack.reserve(From.pack_size());
     if (ImportTemplateArguments(From.pack_begin(), From.pack_size(), ToPack))
       return TemplateArgument();
     
     TemplateArgument *ToArgs 
       = new (Importer.getToContext()) TemplateArgument[ToPack.size()];
     std::copy(ToPack.begin(), ToPack.end(), ToArgs);
-    return TemplateArgument(ToArgs, ToPack.size());
+    return TemplateArgument(ToArgs, ToPack.size(), From.isPackNonType());
   }
   }
   
   llvm_unreachable("Invalid template argument kind");
 }
 
 bool ASTNodeImporter::ImportTemplateArguments(const TemplateArgument *FromArgs,
                                               unsigned NumFromArgs,

lib/AST/DeclTemplate.cpp

if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*Param)) {
       TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*Param);
       if (TTP->isParameterPack())
         Arg = TemplateArgument(TemplateName(TTP), Optional<unsigned>());
       else
         Arg = TemplateArgument(TemplateName(TTP));
     }
     
     if ((*Param)->isTemplateParameterPack())
-      Arg = TemplateArgument::CreatePackCopy(Context, &Arg, 1);
-    
+      Arg = TemplateArgument::CreatePackCopy(
+          Context, &Arg, 1, isa<NonTypeTemplateParmDecl>(*Param));
     *Args++ = Arg;
   }
 }
                                       
 //===----------------------------------------------------------------------===//
 // FunctionTemplateDecl Implementation
 //===----------------------------------------------------------------------===//
 

lib/AST/ExprCXX.cpp

SubstNonTypeTemplateParmPackExpr(QualType T,
                                  SourceLocation NameLoc,
                                  const TemplateArgument &ArgPack)
   : Expr(SubstNonTypeTemplateParmPackExprClass, T, VK_RValue, OK_Ordinary, 
          true, true, true, true),
     Param(Param), Arguments(ArgPack.pack_begin()), 
     NumArguments(ArgPack.pack_size()), NameLoc(NameLoc) { }
 
 TemplateArgument SubstNonTypeTemplateParmPackExpr::getArgumentPack() const {
-  return TemplateArgument(Arguments, NumArguments);
+  return TemplateArgument(Arguments, NumArguments, /*IsNonType=*/true);
 }
 
 FunctionParmPackExpr::FunctionParmPackExpr(QualType T, ParmVarDecl *ParamPack,
                                            SourceLocation NameLoc,
                                            unsigned NumParams,
                                            Decl * const *Params)
   : Expr(FunctionParmPackExprClass, T, VK_LValue, OK_Ordinary,
          true, true, true, true),

lib/AST/MicrosoftMangle.cpp

case TemplateArgument::NullPtr: {
     break;
   }
   case TemplateArgument::Expression:
     mangleExpression(TA.getAsExpr());
     break;
   case TemplateArgument::Pack: {
     ArrayRef<TemplateArgument> TemplateArgs = TA.getPackAsArray();
     if (TemplateArgs.empty()) {
+      if (TA.isPackNonType())
         Out << "$S";
+      else
+        Out << "$$$V";
     } else {
       for (const TemplateArgument &PA : TemplateArgs)
         mangleTemplateArg(TD, PA);
     }
     break;
   }
   case TemplateArgument::Template: {
     const NamedDecl *ND =

lib/AST/TemplateBase.cpp

if (NumWords > 1) {
     Integer.VAL = Value.getZExtValue();
   }
 
   Integer.Type = Type.getAsOpaquePtr();
 }
 
 TemplateArgument TemplateArgument::CreatePackCopy(ASTContext &Context,
                                                   const TemplateArgument *Args,
-                                                  unsigned NumArgs) {
+                                                  unsigned NumArgs,
+                                                  bool IsNonType) {
   if (NumArgs == 0)
-    return getEmptyPack();
+    return getEmptyPack(IsNonType);
   
   TemplateArgument *Storage = new (Context) TemplateArgument [NumArgs];
   std::copy(Args, Args + NumArgs, Storage);
-  return TemplateArgument(Storage, NumArgs);
+  return TemplateArgument(Storage, NumArgs, IsNonType);
 }
 
 bool TemplateArgument::isDependent() const {
   switch (getKind()) {
   case Null:
     llvm_unreachable("Should not have a NULL template argument");
 
   case Type:

lib/AST/TemplateName.cpp

 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/LangOptions.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace clang;
 using namespace llvm;
 
 TemplateArgument 
 SubstTemplateTemplateParmPackStorage::getArgumentPack() const {
-  return TemplateArgument(Arguments, size());
+  return TemplateArgument(Arguments, size(), /*IsNonType=*/false);
 }
 
 void SubstTemplateTemplateParmStorage::Profile(llvm::FoldingSetNodeID &ID) {
   Profile(ID, Parameter, Replacement);
 }
 
 void SubstTemplateTemplateParmStorage::Profile(llvm::FoldingSetNodeID &ID, 
                                            TemplateTemplateParmDecl *parameter,
                                                TemplateName replacement) {
   ID.AddPointer(parameter);
   ID.AddPointer(replacement.getAsVoidPointer());
 }
 
 void SubstTemplateTemplateParmPackStorage::Profile(llvm::FoldingSetNodeID &ID,
                                                    ASTContext &Context) {
-  Profile(ID, Context, Parameter, TemplateArgument(Arguments, size()));
+  Profile(ID, Context, Parameter,
+          TemplateArgument(Arguments, size(), /*IsNonType=*/false));
 }
 
 void SubstTemplateTemplateParmPackStorage::Profile(llvm::FoldingSetNodeID &ID, 
                                                    ASTContext &Context,
                                            TemplateTemplateParmDecl *Parameter,
                                              const TemplateArgument &ArgPack) {
   ID.AddPointer(Parameter);
   ArgPack.Profile(ID, Context);

lib/AST/Type.cpp

SubstTemplateTypeParmPackType(const TemplateTypeParmType *Param,
                               const TemplateArgument &ArgPack)
   : Type(SubstTemplateTypeParmPack, Canon, true, true, false, true), 
     Replaced(Param), 
     Arguments(ArgPack.pack_begin()), NumArguments(ArgPack.pack_size()) 
 { 
 }
 
 TemplateArgument SubstTemplateTypeParmPackType::getArgumentPack() const {
-  return TemplateArgument(Arguments, NumArguments);
+  return TemplateArgument(Arguments, NumArguments, /*IsNonType=*/false);
 }
 
 void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID) {
   Profile(ID, getReplacedParameter(), getArgumentPack());
 }
 
 void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID,
                                            const TemplateTypeParmType *Replaced,

lib/Sema/SemaTemplate.cpp

for (TemplateParameterList::iterator Param = Params->begin(),
                                        ParamEnd = Params->end();
        Param != ParamEnd; /* increment in loop */) {
     // If we have an expanded parameter pack, make sure we don't have too
     // many arguments.
     if (Optional<unsigned> Expansions = getExpandedPackSize(*Param)) {
       if (*Expansions == ArgumentPack.size()) {
         // We're done with this parameter pack. Pack up its arguments and add
         // them to the list.
-        Converted.push_back(
-          TemplateArgument::CreatePackCopy(Context,
-                                           ArgumentPack.data(),
-                                           ArgumentPack.size()));
+        Converted.push_back(TemplateArgument::CreatePackCopy(
+            Context, ArgumentPack.data(), ArgumentPack.size(),
+            isa<NonTypeTemplateParmDecl>(*Param)));
         ArgumentPack.clear();
 
         // This argument is assigned to the next parameter.
         ++Param;
         continue;
       } else if (ArgIdx == NumArgs && !PartialTemplateArgs) {
         // Not enough arguments for this parameter pack.
         Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
if (ArgIdx < NumArgs) {
             ArgumentPack.push_back(TemplateArgs[ArgIdx].getArgument());
           else
             Converted.push_back(TemplateArgs[ArgIdx].getArgument());
           ++ArgIdx;
         }
 
         // Push the argument pack onto the list of converted arguments.
         if (InFinalParameterPack) {
-          Converted.push_back(
-            TemplateArgument::CreatePackCopy(Context,
-                                             ArgumentPack.data(),
-                                             ArgumentPack.size()));
+          Converted.push_back(TemplateArgument::CreatePackCopy(
+              Context, ArgumentPack.data(), ArgumentPack.size(),
+              isa<NonTypeTemplateParmDecl>(*Param)));
           ArgumentPack.clear();
         }
 
         return false;
       }
 
       continue;
     }
 
     // If we're checking a partial template argument list, we're done.
     if (PartialTemplateArgs) {
       if ((*Param)->isTemplateParameterPack() && !ArgumentPack.empty())
-        Converted.push_back(TemplateArgument::CreatePackCopy(Context,
-                                                         ArgumentPack.data(),
-                                                         ArgumentPack.size()));
-        
+        Converted.push_back(TemplateArgument::CreatePackCopy(
+            Context, ArgumentPack.data(), ArgumentPack.size(),
+            isa<NonTypeTemplateParmDecl>(*Param)));
       return false;
     }
 
     // If we have a template parameter pack with no more corresponding
     // arguments, just break out now and we'll fill in the argument pack below.
     if ((*Param)->isTemplateParameterPack()) {
       assert(!getExpandedPackSize(*Param) &&
              "Should have dealt with this already");
 
       // A non-expanded parameter pack before the end of the parameter list
       // only occurs for an ill-formed template parameter list, unless we've
       // got a partial argument list for a function template, so just bail out.
       if (Param + 1 != ParamEnd)
         return true;
 
-      Converted.push_back(TemplateArgument::CreatePackCopy(Context,
-                                                       ArgumentPack.data(),
-                                                       ArgumentPack.size()));
+      Converted.push_back(TemplateArgument::CreatePackCopy(
+          Context, ArgumentPack.data(), ArgumentPack.size(),
+          isa<NonTypeTemplateParmDecl>(*Param)));
       ArgumentPack.clear();
 
       ++Param;
       continue;
     }
 
     // Check whether we have a default argument.
     TemplateArgumentLoc Arg;

lib/Sema/SemaTemplateDeduction.cpp

for (auto &Pack : Packs) {
         DeducedArg = DeducedTemplateArgument();
       }
     }
   }
 
   /// \brief Finish template argument deduction for a set of argument packs,
   /// producing the argument packs and checking for consistency with prior
   /// deductions.
-  Sema::TemplateDeductionResult finish(bool HasAnyArguments) {
+  Sema::TemplateDeductionResult finish(bool HasAnyArguments, bool IsNonType) {
     // Build argument packs for each of the parameter packs expanded by this
     // pack expansion.
     for (auto &Pack : Packs) {
       // Put back the old value for this pack.
       Deduced[Pack.Index] = Pack.Saved;
 
       // Build or find a new value for this pack.
       DeducedTemplateArgument NewPack;
       if (HasAnyArguments && Pack.New.empty()) {
         if (Pack.DeferredDeduction.isNull()) {
           // We were not able to deduce anything for this parameter pack
           // (because it only appeared in non-deduced contexts), so just
           // restore the saved argument pack.
           continue;
         }
 
         NewPack = Pack.DeferredDeduction;
         Pack.DeferredDeduction = TemplateArgument();
       } else if (Pack.New.empty()) {
         // If we deduced an empty argument pack, create it now.
-        NewPack = DeducedTemplateArgument(TemplateArgument::getEmptyPack());
+        NewPack =
+            DeducedTemplateArgument(TemplateArgument::getEmptyPack(IsNonType));
       } else {
         TemplateArgument *ArgumentPack =
             new (S.Context) TemplateArgument[Pack.New.size()];
         std::copy(Pack.New.begin(), Pack.New.end(), ArgumentPack);
         NewPack = DeducedTemplateArgument(
-            TemplateArgument(ArgumentPack, Pack.New.size()),
+            TemplateArgument(ArgumentPack, Pack.New.size(), IsNonType),
             Pack.New[0].wasDeducedFromArrayBound());
       }
 
       // Pick where we're going to put the merged pack.
       DeducedTemplateArgument *Loc;
       if (Pack.Outer) {
         if (Pack.Outer->DeferredDeduction.isNull()) {
           // Defer checking this pack until we have a complete pack to compare
for (; ArgIdx < NumArgs; ++ArgIdx) {
                                                  RefParamComparisons))
         return Result;
 
       PackScope.nextPackElement();
     }
 
     // Build argument packs for each of the parameter packs expanded by this
     // pack expansion.
-    if (auto Result = PackScope.finish(HasAnyArguments))
+    if (auto Result = PackScope.finish(HasAnyArguments,
+                                       /*IsNonType=*/false))
       return Result;
   }
 
   // Make sure we don't have any extra arguments.
   if (ArgIdx < NumArgs)
     return Sema::TDK_MiscellaneousDeductionFailure;
 
   return Sema::TDK_Success;
for (; hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs); ++ArgIdx) {
                                       Info, Deduced))
         return Result;
 
       PackScope.nextPackElement();
     }
 
     // Build argument packs for each of the parameter packs expanded by this
     // pack expansion.
-    if (auto Result = PackScope.finish(HasAnyArguments))
+    TemplateArgument::ArgKind AK = Params[ParamIdx].getKind();
+    bool IsNonType;
+    if (AK == TemplateArgument::Pack)
+      IsNonType = Params[ParamIdx].isPackNonType();
+    else
+      IsNonType = AK == TemplateArgument::Integral ||
+                  AK == TemplateArgument::NullPtr ||
+                  AK == TemplateArgument::Declaration;
+    if (auto Result = PackScope.finish(HasAnyArguments, IsNonType))
       return Result;
   }
 
   return Sema::TDK_Success;
 }
 
 static Sema::TemplateDeductionResult
 DeduceTemplateArguments(Sema &S,
for (const auto &P : Arg.pack_elements()) {
                                          Info, InFunctionTemplate, Output))
         return true;
 
       // Move the converted template argument into our argument pack.
       PackedArgsBuilder.push_back(Output.pop_back_val());
     }
 
     // Create the resulting argument pack.
-    Output.push_back(TemplateArgument::CreatePackCopy(S.Context,
-                                                      PackedArgsBuilder.data(),
-                                                     PackedArgsBuilder.size()));
+    Output.push_back(TemplateArgument::CreatePackCopy(
+        S.Context, PackedArgsBuilder.data(), PackedArgsBuilder.size(),
+        Arg.isPackNonType()));
     return false;
   }
 
   // Convert the deduced template argument into a template
   // argument that we can check, almost as if the user had written
   // the template argument explicitly.
   TemplateArgumentLoc ArgLoc = getTrivialTemplateArgumentLoc(S, Arg, NTTPType,
                                                              Info.getLocation());
if (Param->isTemplateParameterPack()) {
       // template parameter pack. If so, our empty deduction extends the
       // explicitly-specified set (C++0x [temp.arg.explicit]p9).
       const TemplateArgument *ExplicitArgs;
       unsigned NumExplicitArgs;
       if (CurrentInstantiationScope &&
           CurrentInstantiationScope->getPartiallySubstitutedPack(&ExplicitArgs,
                                                              &NumExplicitArgs)
             == Param) {
-        Builder.push_back(TemplateArgument(ExplicitArgs, NumExplicitArgs));
+        Builder.push_back(
+            TemplateArgument(ExplicitArgs, NumExplicitArgs,
+                             isa<NonTypeTemplateParmDecl>(Param)));
 
         // Forget the partially-substituted pack; it's substitution is now
         // complete.
         CurrentInstantiationScope->ResetPartiallySubstitutedPack();
       } else {
-        Builder.push_back(TemplateArgument::getEmptyPack());
+        Builder.push_back(TemplateArgument::getEmptyPack(
+            isa<NonTypeTemplateParmDecl>(Param)));
       }
       continue;
     }
 
     // Substitute into the default template argument, if available.
     bool HasDefaultArg = false;
     TemplateArgumentLoc DefArg
       = SubstDefaultTemplateArgumentIfAvailable(FunctionTemplate,
for (; ArgIdx < Args.size(); ++ArgIdx) {
           return Result;
       }
 
       PackScope.nextPackElement();
     }
 
     // Build argument packs for each of the parameter packs expanded by this
     // pack expansion.
-    if (auto Result = PackScope.finish(HasAnyArguments))
+    if (auto Result = PackScope.finish(HasAnyArguments, /*IsNonType=*/false))
       return Result;
 
     // After we've matching against a parameter pack, we're done.
     break;
   }
 
   return FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
                                          NumExplicitlySpecified, Specialization,

lib/Serialization/ASTReader.cpp

ASTReader::ReadTemplateArgument(ModuleFile &F,
   }
   case TemplateArgument::Expression:
     return TemplateArgument(ReadExpr(F));
   case TemplateArgument::Pack: {
     unsigned NumArgs = Record[Idx++];
     TemplateArgument *Args = new (Context) TemplateArgument[NumArgs];
     for (unsigned I = 0; I != NumArgs; ++I)
       Args[I] = ReadTemplateArgument(F, Record, Idx);
-    return TemplateArgument(Args, NumArgs);
+    // FIXME: this is wrong!
+    return TemplateArgument(Args, NumArgs, /*IsNonType=*/false);
   }
   }
 
   llvm_unreachable("Unhandled template argument kind!");
 }
 
 TemplateParameterList *
 ASTReader::ReadTemplateParameterList(ModuleFile &F,

test/CodeGenCXX/mangle-ms-cxx11.cpp

 // CHECK-DAG: @"\01??__K_deg@@YAHO@Z"
 
 template <char...>
 void templ_fun_with_pack() {}
 
 template void templ_fun_with_pack<>();
 // CHECK-DAG: @"\01??$templ_fun_with_pack@$S@@YAXXZ"
 
+template <typename...>
+void templ_fun_with_type_pack() {}
+
+template void templ_fun_with_type_pack<>();
+// CHECK-DAG: @"\01??$templ_fun_with_type_pack@$$$V@@YAXXZ"
+
 namespace PR20047 {
 template <typename T>
 struct A {};
 
 template <typename T>
 using AliasA = A<T>;
 
 template <template <typename> class>
 void f() {}
 
 template void f<AliasA>();
 // CHECK-DAG: @"\01??$f@$@PR20047@@YAXXZ"
 }