Treat an unqualified RecordType as a RecordDecl when substituting.

llvm-svn: 82123

1 files changed, 21 insertions, 14 deletions

diff --git a/clang/lib/CodeGen/Mangle.cpp b/clang/lib/CodeGen/Mangle.cpp
index 8241ad61d07..f42e395e55a 100644
--- a/clang/lib/CodeGen/Mangle.cpp
+++ b/clang/lib/CodeGen/Mangle.cpp
@@ -93,8 +93,8 @@ namespace {
     void mangleCXXCtorType(CXXCtorType T);
     void mangleCXXDtorType(CXXDtorType T);
 
-    void mangleTemplateArgumentList(const TemplateArgumentList &L);
-    void mangleTemplateArgument(const TemplateArgument &A);
+    void mangleTemplateArgs(const TemplateArgumentList &L);
+    void mangleTemplateArg(const TemplateArgument &A);
   };
 }
 
@@ -252,9 +252,10 @@ void CXXNameMangler::mangleName(const NamedDecl *ND) {
   if (ND->getDeclContext()->isTranslationUnit() ||
       isStdNamespace(ND->getDeclContext())) {
     const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND);
-    if (FD && FD->getPrimaryTemplate()) 
+    if (FD && FD->getPrimaryTemplate()) {
       mangleUnscopedTemplateName(FD);
-    else
+      mangleTemplateArgs(*FD->getTemplateSpecializationArgs());
+    } else
       mangleUnscopedName(ND);
   } else if (isa<FunctionDecl>(ND->getDeclContext()))
     mangleLocalName(ND);
@@ -386,12 +387,6 @@ void CXXNameMangler::mangleUnqualifiedName(const NamedDecl *ND) {
     assert(false && "Can't mangle a using directive name!");
     break;
   }
-
-  if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(ND)) {
-    if (const TemplateArgumentList *TemplateArgs
-          = Function->getTemplateSpecializationArgs())
-      mangleTemplateArgumentList(*TemplateArgs);
-  }
 }
 
 void CXXNameMangler::mangleSourceName(const IdentifierInfo *II) {
@@ -715,7 +710,7 @@ void CXXNameMangler::mangleType(const TagType *T) {
   // If this is a class template specialization, mangle the template arguments.
   if (ClassTemplateSpecializationDecl *Spec
       = dyn_cast<ClassTemplateSpecializationDecl>(T->getDecl()))
-    mangleTemplateArgumentList(Spec->getTemplateArgs());
+    mangleTemplateArgs(Spec->getTemplateArgs());
 }
 
 // <type>       ::= <array-type>
@@ -877,20 +872,20 @@ void CXXNameMangler::mangleCXXDtorType(CXXDtorType T) {
   }
 }
 
-void CXXNameMangler::mangleTemplateArgumentList(const TemplateArgumentList &L) {
+void CXXNameMangler::mangleTemplateArgs(const TemplateArgumentList &L) {
   // <template-args> ::= I <template-arg>+ E
   Out << "I";
 
   for (unsigned i = 0, e = L.size(); i != e; ++i) {
     const TemplateArgument &A = L[i];
 
-    mangleTemplateArgument(A);
+    mangleTemplateArg(A);
   }
 
   Out << "E";
 }
 
-void CXXNameMangler::mangleTemplateArgument(const TemplateArgument &A) {
+void CXXNameMangler::mangleTemplateArg(const TemplateArgument &A) {
   // <template-arg> ::= <type>              # type or template
   //                ::= X <expression> E    # expression
   //                ::= <expr-primary>      # simple expressions
@@ -932,6 +927,11 @@ bool CXXNameMangler::mangleSubstitution(const NamedDecl *ND) {
 }
 
 bool CXXNameMangler::mangleSubstitution(QualType T) {
+  if (!T.getCVRQualifiers()) {
+    if (const RecordType *RT = dyn_cast<RecordType>(T))
+      return mangleSubstitution(RT->getDecl());
+  }
+  
   uintptr_t TypePtr = reinterpret_cast<uintptr_t>(T.getAsOpaquePtr());
 
   return mangleSubstitution(TypePtr);
@@ -972,6 +972,13 @@ bool CXXNameMangler::mangleSubstitution(uintptr_t Ptr) {
 }
 
 void CXXNameMangler::addSubstitution(QualType T) {
+  if (!T.getCVRQualifiers()) {
+    if (const RecordType *RT = dyn_cast<RecordType>(T)) {
+      addSubstitution(RT->getDecl());
+      return;
+    }
+  }
+  
   uintptr_t TypePtr = reinterpret_cast<uintptr_t>(T.getAsOpaquePtr());
   addSubstitution(TypePtr);
 }