procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

re PR c++/46807 (internal compiler error: in synthesized_method_walk)

Browse source 
PR c++/46807
	* method.c (synthesized_method_walk): Always exit early for
	trivial fn in C++98 mode.

From-SVN: r170207
This commit is contained in:
Jason Merrill 2011-02-15 19:39:27 -05:00 • committed by Jason Merrill
parent aa2bf28660
commit 503c8e860b
5 changed files with 61 additions and 11 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
gcc/cp/ChangeLog
View file

@ -1,3 +1,9 @@
2011-02-15 Jason Merrill <jason@redhat.com>
PR c++/46807
* method.c (synthesized_method_walk): Always exit early for
trivial fn in C++98 mode.
2011-02-14 Jason Merrill <jason@redhat.com>
PR c++/47482

15
gcc/cp/method.c
View file

@ -1153,13 +1153,15 @@ synthesized_method_walk (tree ctype, special_function_kind sfk, bool const_p,
if (trivial_p)
*trivial_p = expected_trivial;
#ifndef ENABLE_CHECKING
/* The TYPE_HAS_COMPLEX_* flags tell us about constraints from base
class versions and other properties of the type. But a subobject
class can be trivially copyable and yet have overload resolution
choose a template constructor for initialization, depending on
rvalueness and cv-quals. So we can't exit early for copy/move
methods in C++0x. */
methods in C++0x. The same considerations apply in C++98/03, but
there the definition of triviality does not consider overload
resolution, so a constructor can be trivial even if it would otherwise
call a non-trivial constructor. */
if (expected_trivial
&& (!copy_arg_p || cxx_dialect < cxx0x))
{
@ -1167,7 +1169,6 @@ synthesized_method_walk (tree ctype, special_function_kind sfk, bool const_p,
*constexpr_p = synthesized_default_constructor_is_constexpr (ctype);
return;
}
#endif
++cp_unevaluated_operand;
++c_inhibit_evaluation_warnings;
@ -1300,14 +1301,6 @@ synthesized_method_walk (tree ctype, special_function_kind sfk, bool const_p,
if (spec_p)
*spec_p = merge_exception_specifiers (*spec_p, cleanup_spec);
}
#ifdef ENABLE_CHECKING
/* If we expected this to be trivial but it isn't, then either we're in
C++0x mode and this is a copy/move ctor/op= or there's an error. */
gcc_assert (!(trivial_p && expected_trivial && !*trivial_p)
|| (copy_arg_p && cxx_dialect >= cxx0x)
|| errorcount);
#endif
}
/* DECL is a deleted function. If it's implicitly deleted, explain why and

5
gcc/testsuite/ChangeLog
View file

@ -1,3 +1,8 @@
2011-02-15 Jason Merrill <jason@redhat.com>
* g++.dg/inherit/implicit-trivial1.C: New.
* g++.dg/cpp0x/implicit-trivial1.C: New.
2011-02-15 H.J. Lu <hongjiu.lu@intel.com>
PR middle-end/47725

23
gcc/testsuite/g++.dg/cpp0x/implicit-trivial1.C Normal file
View file

@ -0,0 +1,23 @@
// PR c++/46807
// { dg-options -std=c++0x }
// In C++98/03, B::B(const B&) is trivial because A::A(const A&) is trivial,
// even though doing overload resolution would mean calling the template
// constructor. In C++0x, we do overload resolution to determine triviality.
struct A
{
A() {}
private:
template <class T> A(T&); // { dg-error "private" }
};
struct B // { dg-error "implicitly deleted|this context" }
{
mutable A a;
};
int main()
{
B b;
B b2(b); // { dg-error "deleted" }
}

23
gcc/testsuite/g++.dg/inherit/implicit-trivial1.C Normal file
View file

@ -0,0 +1,23 @@
// PR c++/46807
// { dg-options -std=c++98 }
// In C++98/03, B::B(const B&) is trivial because A::A(const A&) is trivial,
// even though doing overload resolution would mean calling the template
// constructor. In C++0x, we do overload resolution to determine triviality.
struct A
{
A() {}
private:
template <class T> A(T&);
};
struct B
{
mutable A a;
};
int main()
{
B b;
B b2(b);
}