Add tests for name mangling of variadic templates.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@123378 91177308-0d34-0410-b5e6-96231b3b80d8

2 files changed, 61 insertions, 6 deletions

diff --git a/lib/CodeGen/Mangle.cpp b/lib/CodeGen/Mangle.cpp
index ff0e9223c8..0dfa0520af 100644
--- a/lib/CodeGen/Mangle.cpp
+++ b/lib/CodeGen/Mangle.cpp
@@ -1476,7 +1476,7 @@ void CXXNameMangler::mangleType(const DependentSizedExtVectorType *T) {
 }
 
 void CXXNameMangler::mangleType(const PackExpansionType *T) {
-  // FIXME: We may need to push this mangling into the callers
+  // <type>  ::= Dp <type>          # pack expansion (C++0x)
   Out << "sp";
   mangleType(T->getPattern());
 }
@@ -1626,6 +1626,7 @@ void CXXNameMangler::mangleExpression(const Expr *E, unsigned Arity) {
   //              ::= sr <type> <unqualified-name>                   # dependent name
   //              ::= sr <type> <unqualified-name> <template-args>   # dependent template-id
   //              ::= sZ <template-param>                            # size of a parameter pack
+  //              ::= sZ <function-param>    # size of a function parameter pack
   //              ::= <expr-primary>
   // <expr-primary> ::= L <type> <value number> E    # integer literal
   //                ::= L <type <value float> E      # floating literal
@@ -2050,7 +2051,6 @@ void CXXNameMangler::mangleExpression(const Expr *E, unsigned Arity) {
     break;
       
   case Expr::SizeOfPackExprClass: {
-    // FIXME: Variadic templates missing mangling for function parameter packs?
     Out << "sZ";
     const NamedDecl *Pack = cast<SizeOfPackExpr>(E)->getPack();
     if (const TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Pack))
@@ -2062,7 +2062,8 @@ void CXXNameMangler::mangleExpression(const Expr *E, unsigned Arity) {
                                     = dyn_cast<TemplateTemplateParmDecl>(Pack))
       mangleTemplateParameter(TempTP->getIndex());
     else {
-      // FIXME: This case isn't handled by the Itanium C++ ABI
+      // Note: proposed by Mike Herrick on 11/30/10
+      // <expression> ::= sZ <function-param>  # size of function parameter pack
       Diagnostic &Diags = Context.getDiags();
       unsigned DiagID = Diags.getCustomDiagID(Diagnostic::Error,
                             "cannot mangle sizeof...(function parameter pack)");
@@ -2156,7 +2157,7 @@ void CXXNameMangler::mangleTemplateArg(const NamedDecl *P,
   // <template-arg> ::= <type>              # type or template
   //                ::= X <expression> E    # expression
   //                ::= <expr-primary>      # simple expressions
-  //                ::= I <template-arg>* E # argument pack
+  //                ::= J <template-arg>* E # argument pack
   //                ::= sp <expression>     # pack expansion of (C++0x)
   switch (A.getKind()) {
   case TemplateArgument::Null:
@@ -2170,7 +2171,7 @@ void CXXNameMangler::mangleTemplateArg(const NamedDecl *P,
     mangleType(A.getAsTemplate());
     break;
   case TemplateArgument::TemplateExpansion:
-    // This is mangled as Dp <type>.
+    // <type>  ::= Dp <type>          # pack expansion (C++0x)
     Out << "Dp";
     mangleType(A.getAsTemplateOrTemplatePattern());
     break;
diff --git a/test/CodeGenCXX/mangle-variadic-templates.cpp b/test/CodeGenCXX/mangle-variadic-templates.cpp
index e078f3e3ba..0167726b0d 100644
--- a/test/CodeGenCXX/mangle-variadic-templates.cpp
+++ b/test/CodeGenCXX/mangle-variadic-templates.cpp
@@ -1,8 +1,14 @@
-// RUN: %clang_cc1 -std=c++0x -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -std=c++0x -emit-llvm -triple=x86_64-apple-darwin9 -o - %s | FileCheck %s
 
 template<unsigned I, typename ...Types>
 struct X { };
 
+template<typename T> struct identity { };
+template<typename T> struct add_reference;
+template<typename ...Types> struct tuple { };
+template<int ...Values> struct int_tuple { };
+template<template<typename> class ...Templates> struct template_tuple { };
+
 // CHECK: define weak_odr void @_Z2f0IJEEv1XIXsZT_EJspRT_EE
 template<typename ...Types>
 void f0(X<sizeof...(Types), Types&...>) { }
@@ -11,3 +17,51 @@ template void f0(X<0>);
 
 // CHECK: define weak_odr void @_Z2f0IJifdEEv1XIXsZT_EJspRT_EE
 template void f0<int, float, double>(X<3, int&, float&, double&>);
+
+// Mangling for template argument packs
+template<typename ...Types> void f1() {}
+// CHECK: define weak_odr void @_Z2f1IJEEvv
+template void f1<>();
+// CHECK: define weak_odr void @_Z2f1IJiEEvv
+template void f1<int>();
+// CHECK: define weak_odr void @_Z2f1IJifEEvv
+template void f1<int, float>();
+
+// Mangling function parameter packs
+template<typename ...Types> void f2(Types...) {}
+// CHECK: define weak_odr void @_Z2f2IJEEvspT_
+template void f2<>();
+// CHECK: define weak_odr void @_Z2f2IJiEEvspT_
+template void f2<int>(int);
+// CHECK: define weak_odr void @_Z2f2IJifEEvspT_
+template void f2<int, float>(int, float);
+
+// Mangling non-trivial function parameter packs
+template<typename ...Types> void f3(const Types *...) {}
+// CHECK: define weak_odr void @_Z2f3IJEEvspPKT_
+template void f3<>();
+// CHECK: define weak_odr void @_Z2f3IJiEEvspPKT_
+template void f3<int>(const int*);
+// CHECK: define weak_odr void @_Z2f3IJifEEvspPKT_
+template void f3<int, float>(const int*, const float*);
+
+// Mangling of type pack expansions in a template argument
+template<typename ...Types> tuple<Types...> f4() {}
+// CHECK: define weak_odr void @_Z2f4IJifdEE5tupleIJspT_EEv
+template tuple<int, float, double> f4();
+
+// Mangling of type pack expansions in a function type
+template<typename R, typename ...ArgTypes> identity<R(ArgTypes...)> f5() {}
+// CHECK: define weak_odr void @_Z2f5IiJifdEE8identityIFT_spT0_EEv
+template identity<int(int, float, double)> f5();
+
+// Mangling of non-type template argument expansions
+template<int ...Values> int_tuple<Values...> f6() {}
+// CHECK: define weak_odr void @_Z2f6IJLi1ELi2ELi3EEE9int_tupleIJXspT_EEEv
+template int_tuple<1, 2, 3> f6();
+
+// Mangling of template template argument expansions
+template<template<typename> class ...Templates> 
+template_tuple<Templates...> f7() {}
+// CHECK: define weak_odr void @_Z2f7IJ8identity13add_referenceEE14template_tupleIJDpT_EEv
+template template_tuple<identity, add_reference> f7();