Mangle explicit template arguments in dependent or overloaded names.

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

diff --git a/lib/CodeGen/Mangle.cpp b/lib/CodeGen/Mangle.cpp
index 30fd668b0c28200561f104cebff0342ca0f025c5..312bc9920d92a6bc00d9b37973b5aaeda7d33350 100644 (file)
--- a/lib/CodeGen/Mangle.cpp
+++ b/lib/CodeGen/Mangle.cpp
@@ -245,6 +245,7 @@ private:
   void mangleCXXCtorType(CXXCtorType T);
   void mangleCXXDtorType(CXXDtorType T);
 
+  void mangleTemplateArgs(const ExplicitTemplateArgumentList &TemplateArgs);
   void mangleTemplateArgs(TemplateName Template,
                           const TemplateArgument *TemplateArgs,
                           unsigned NumTemplateArgs);  
@@ -1676,6 +1677,8 @@ void CXXNameMangler::mangleExpression(const Expr *E, unsigned Arity) {
     mangleMemberExpr(ME->getBase(), ME->isArrow(),
                      ME->getQualifier(), ME->getMemberName(),
                      Arity);
+    if (ME->hasExplicitTemplateArgs())
+      mangleTemplateArgs(ME->getExplicitTemplateArgs());
     break;
   }
 
@@ -1685,6 +1688,8 @@ void CXXNameMangler::mangleExpression(const Expr *E, unsigned Arity) {
     mangleMemberExpr(ME->getBase(), ME->isArrow(),
                      ME->getQualifier(), ME->getMember(),
                      Arity);
+    if (ME->hasExplicitTemplateArgs())
+      mangleTemplateArgs(ME->getExplicitTemplateArgs());
     break;
   }
 
@@ -1694,6 +1699,8 @@ void CXXNameMangler::mangleExpression(const Expr *E, unsigned Arity) {
     // expression.
     const UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>(E);
     mangleUnresolvedName(ULE->getQualifier(), ULE->getName(), Arity);
+    if (ULE->hasExplicitTemplateArgs())
+      mangleTemplateArgs(ULE->getExplicitTemplateArgs());
     break;
   }
 
@@ -1888,10 +1895,13 @@ void CXXNameMangler::mangleExpression(const Expr *E, unsigned Arity) {
     }
     assert(QTy && "Qualifier was not type!");
 
-    // ::= sr <type> <unqualified-name>                   # dependent name
+    // ::= sr <type> <unqualified-name>                  # dependent name
+    // ::= sr <type> <unqualified-name> <template-args>  # dependent template-id
     Out << "sr";
     mangleType(QualType(QTy, 0));
     mangleUnqualifiedName(0, DRE->getDeclName(), Arity);
+    if (DRE->hasExplicitTemplateArgs())
+      mangleTemplateArgs(DRE->getExplicitTemplateArgs());
 
     break;
   }
@@ -2020,6 +2030,15 @@ void CXXNameMangler::mangleCXXDtorType(CXXDtorType T) {
   }
 }
 
+void CXXNameMangler::mangleTemplateArgs(
+                          const ExplicitTemplateArgumentList &TemplateArgs) {
+  // <template-args> ::= I <template-arg>+ E
+  Out << 'I';
+  for (unsigned I = 0, E = TemplateArgs.NumTemplateArgs; I != E; ++I)
+    mangleTemplateArg(0, TemplateArgs.getTemplateArgs()[I].getArgument());
+  Out << 'E';
+}
+
 void CXXNameMangler::mangleTemplateArgs(TemplateName Template,
                                         const TemplateArgument *TemplateArgs,
                                         unsigned NumTemplateArgs) {

diff --git a/test/CodeGenCXX/mangle.cpp b/test/CodeGenCXX/mangle.cpp
index c7a6e0096bd9020189cc69e9a74cf75c425af48e..55357c7d63a47561d2a718c97cdbf80dd3b118b7 100644 (file)
--- a/test/CodeGenCXX/mangle.cpp
+++ b/test/CodeGenCXX/mangle.cpp
@@ -551,10 +551,10 @@ namespace test17 {
 
   template <class T> A<sizeof(T::foo())> func(void);
 
-  // CHECK: define i32 @_ZN6test174testEv()
+  // CHECK: define void @_ZN6test174testEv()
   // CHECK: call {{.*}} @_ZN6test174funcINS_1BEEENS_1AIXszclsrT_3fooEEEEv()
-  int test() {
-    func<B>();  // { dg-error "sorry, unimplemented" }
+  void test() {
+    func<B>();
   }
 }
 
@@ -585,3 +585,42 @@ namespace test18 {
   // CHECK: define weak_odr void @_ZN6test181fINS_1AEEEvNS_1SIXadsrT_mlEEE
   // CHECK: define weak_odr void @_ZN6test181fINS_1AEEEvNS_1SIXadsrT_anEEE
 }
+
+// rdar://problem/8332117
+namespace test19 {
+  struct A {
+    template <typename T> int f();
+    int operator+();
+    operator int();
+    template <typename T> int operator-();
+  };
+
+  template <int (A::*)()> struct S {};
+
+  template <typename T> void g (S<&T::template f<int> >) {}
+  template <typename T> void g (S<&T::operator+ >) {}
+  template <typename T> void g (S<&T::operator int>) {}
+  template <typename T> void g (S<&T::template operator- <double> >) {}
+
+  // CHECK: define weak_odr void @_ZN6test191gINS_1AEEEvNS_1SIXadsrT_1fIiEEEE(
+  template void g<A>(S<&A::f<int> >);
+  // CHECK: define weak_odr void @_ZN6test191gINS_1AEEEvNS_1SIXadsrT_plEEE(
+  template void g<A>(S<&A::operator+>);
+  // CHECK: define weak_odr void @_ZN6test191gINS_1AEEEvNS_1SIXadsrT_cviEEE(
+  template void g<A>(S<&A::operator int>);
+  // CHECK: define weak_odr void @_ZN6test191gINS_1AEEEvNS_1SIXadsrT_miIdEEEE(
+  template void g<A>(S<&A::operator-<double> >);
+}
+
+namespace test20 {
+  template <class T> T *f(const T&);
+  template <class T> T *f(T*);
+
+  // CHECK: define weak_odr void @_ZN6test205test0IiEEvDTcl1fIPT_ELi0EEE(
+  template <class T> void test0(decltype(f<T*>(0))) {}
+  template void test0<int>(decltype(f<int*>(0)));
+
+  // CHECK: define weak_odr void @_ZN6test205test1IiEEvDTcl1fIEcvT__EEE(
+  template <class T> void test1(decltype(f<>(T()))) {}
+  template void test1<int>(decltype(f<>(int())));
+}