From 86648b13eb01c0565de7264b27799ba81c7ad060 Mon Sep 17 00:00:00 2001 From: Faisal Vali Date: Wed, 26 Jun 2013 02:34:24 +0000 Subject: [PATCH] Fix PCH bug with member templates of local classes in nontemplate functions. As noted by Richard in the post: http://lists.cs.uiuc.edu/pipermail/cfe-commits/Week-of-Mon-20130624/082605.html, the following code should not add an entry into PendingLocalImplicitInstantiations, since local instantiations should only occur within the context of other instantiations: int foo(double y) { struct Lambda { template T operator()(T t) const { return t; }; } lambda; return lambda(y); } Hence the attached code does the following: 1) In MarkFunctionReferenced, check if ActiveInstantiations.size() is non-zero before adding to PendingLocalImplicitInstantiations. 2) In InstantiateFunctionDefinition, we swap out/in PendingLocalImplicitInstantiations so that only those pending local instantiations that are added during the instantiation of the current function are instantiated recursively. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@184903 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Sema/SemaExpr.cpp | 3 +- lib/Sema/SemaTemplateInstantiateDecl.cpp | 6 +++ test/PCH/cxx-local-templates.cpp | 55 ++++++++++++++++++++++ test/PCH/cxx1y-local-templates.cpp | 58 ++++++++++++++++++++++++ 4 files changed, 121 insertions(+), 1 deletion(-) create mode 100644 test/PCH/cxx-local-templates.cpp create mode 100644 test/PCH/cxx1y-local-templates.cpp diff --git a/lib/Sema/SemaExpr.cpp b/lib/Sema/SemaExpr.cpp index 0c3ae1853a..2059a1e076 100644 --- a/lib/Sema/SemaExpr.cpp +++ b/lib/Sema/SemaExpr.cpp @@ -10893,7 +10893,8 @@ void Sema::MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func) { if (!AlreadyInstantiated || Func->isConstexpr()) { if (isa(Func->getDeclContext()) && - cast(Func->getDeclContext())->isLocalClass()) + cast(Func->getDeclContext())->isLocalClass() && + ActiveTemplateInstantiations.size()) PendingLocalImplicitInstantiations.push_back( std::make_pair(Func, PointOfInstantiation)); else if (Func->isConstexpr()) diff --git a/lib/Sema/SemaTemplateInstantiateDecl.cpp b/lib/Sema/SemaTemplateInstantiateDecl.cpp index c947bcc9f2..21a4cb1259 100644 --- a/lib/Sema/SemaTemplateInstantiateDecl.cpp +++ b/lib/Sema/SemaTemplateInstantiateDecl.cpp @@ -2918,6 +2918,10 @@ void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, // while we're still within our own instantiation context. SmallVector SavedVTableUses; std::deque SavedPendingInstantiations; + std::deque + SavedPendingLocalImplicitInstantiations; + SavedPendingLocalImplicitInstantiations.swap( + PendingLocalImplicitInstantiations); if (Recursive) { VTableUses.swap(SavedVTableUses); PendingInstantiations.swap(SavedPendingInstantiations); @@ -2998,6 +3002,8 @@ void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, "PendingInstantiations should be empty before it is discarded."); PendingInstantiations.swap(SavedPendingInstantiations); } + SavedPendingLocalImplicitInstantiations.swap( + PendingLocalImplicitInstantiations); } /// \brief Instantiate the definition of the given variable from its diff --git a/test/PCH/cxx-local-templates.cpp b/test/PCH/cxx-local-templates.cpp new file mode 100644 index 0000000000..277ad83109 --- /dev/null +++ b/test/PCH/cxx-local-templates.cpp @@ -0,0 +1,55 @@ +// RUN: %clang_cc1 -pedantic-errors -std=c++11 -emit-pch %s -o %t-cxx11 +// RUN: %clang_cc1 -ast-print -pedantic-errors -std=c++11 -include-pch %t-cxx11 %s | FileCheck -check-prefix=CHECK-PRINT %s + +#ifndef HEADER_INCLUDED + +#define HEADER_INCLUDED + +int nontemplate_test(double d) { + struct Local { + template T foo(T t) { + return t; + } + }; + return Local{}.foo(d); +} + +template +U template_test(U d) { + struct Local { + template T foo(T t) { + return t; + } + }; + return Local{}.foo(d); +} + +int nested_local() { + struct Inner1 { + int inner1_foo(char c) { + struct Inner2 { + template T inner2_foo(T t) { + return t; + } + }; + return Inner2{}.inner2_foo(3.14); + } + }; + return Inner1{}.inner1_foo('a'); +} + +#else + +// CHECK-PRINT: U template_test + +// CHECK-PRINT: int nontemplate_test(double) + +int nontemplate_test(double); + +template double template_test(double); +int test2(int y) { + return nontemplate_test(y) + template_test(y); +} + + +#endif diff --git a/test/PCH/cxx1y-local-templates.cpp b/test/PCH/cxx1y-local-templates.cpp new file mode 100644 index 0000000000..ccab03d4b4 --- /dev/null +++ b/test/PCH/cxx1y-local-templates.cpp @@ -0,0 +1,58 @@ +// RUN: %clang_cc1 -pedantic-errors -std=c++1y -emit-pch %s -o %t-cxx1y +// RUN: %clang_cc1 -ast-print -pedantic-errors -std=c++1y -include-pch %t-cxx1y %s | FileCheck -check-prefix=CHECK-PRINT %s + +#ifndef HEADER_INCLUDED + +#define HEADER_INCLUDED + +auto nested_local_call_all() { + struct Inner1 { + auto inner1_foo(char c) { + struct Inner2 { + template T inner2_foo(T t) { + return t; + } + }; + return Inner2{}; + } + }; + return Inner1{}.inner1_foo('a').inner2_foo(4); +} + + +auto nested_local() { + struct Inner1 { + auto inner1_foo(char c) { + struct Inner2 { + template T inner2_foo(T t) { + return t; + } + }; + return Inner2{}; + } + }; + return Inner1{}; +} + + +int test() { + auto A = nested_local_call_all(); + auto B = nested_local(); + auto C = B.inner1_foo('a'); + C.inner2_foo(3.14); + +} + + +#else + +// CHECK-PRINT: int nested_local_call_all +// CHECK-PRINT: nested_local +auto nested_local_call_all(); + +int test(int y) { + return nested_local_call_all(); +} + + +#endif -- 2.40.0