From be9e458d8bed984fe13bd7a6daf76bb34ef3ed7f Mon Sep 17 00:00:00 2001 From: Marek Polacek Date: Mon, 20 May 2019 19:10:57 +0000 Subject: [PATCH] CWG 2094 - volatile scalars are trivially copyable. PR c++/85679 * tree.c (trivially_copyable_p): Don't check CP_TYPE_VOLATILE_P for scalar types. * g++.dg/ext/is_trivially_constructible1.C: Change the expected result for volatile int. * g++.dg/ext/is_trivially_copyable.C: New test. * testsuite/20_util/is_trivially_copyable/value.cc: Change the expected result for volatile int. From-SVN: r271435 --- gcc/cp/ChangeLog | 7 +++++++ gcc/cp/tree.c | 3 ++- gcc/testsuite/ChangeLog | 8 ++++++++ .../g++.dg/ext/is_trivially_constructible1.C | 4 +++- gcc/testsuite/g++.dg/ext/is_trivially_copyable.C | 16 ++++++++++++++++ libstdc++-v3/ChangeLog | 7 +++++++ .../20_util/is_trivially_copyable/value.cc | 4 +++- 7 files changed, 46 insertions(+), 3 deletions(-) create mode 100644 gcc/testsuite/g++.dg/ext/is_trivially_copyable.C diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 88275f0ed44..f5f6c444436 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,10 @@ +2019-05-20 Marek Polacek + + CWG 2094 - volatile scalars are trivially copyable. + PR c++/85679 + * tree.c (trivially_copyable_p): Don't check CP_TYPE_VOLATILE_P for + scalar types. + 2019-05-20 Marek Polacek * pt.c (convert_template_argument): Add a diagnostic for the diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c index 8d7f7a2c3e7..78139329476 100644 --- a/gcc/cp/tree.c +++ b/gcc/cp/tree.c @@ -4098,7 +4098,8 @@ trivially_copyable_p (const_tree t) && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t) && TYPE_HAS_TRIVIAL_DESTRUCTOR (t)); else - return !CP_TYPE_VOLATILE_P (t) && scalarish_type_p (t); + /* CWG 2094 makes volatile-qualified scalars trivially copyable again. */ + return scalarish_type_p (t); } /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index be4e7eb895f..c100f6ae53e 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,11 @@ +2019-05-20 Marek Polacek + + CWG 2094 - volatile scalars are trivially copyable. + PR c++/85679 + * g++.dg/ext/is_trivially_constructible1.C: Change the expected result + for volatile int. + * g++.dg/ext/is_trivially_copyable.C: New test. + 2019-05-20 Marek Polacek * g++.dg/ext/utf8-2.C: Accept both "char" and "char8_t" in aka. diff --git a/gcc/testsuite/g++.dg/ext/is_trivially_constructible1.C b/gcc/testsuite/g++.dg/ext/is_trivially_constructible1.C index 191b69601e6..d28f2f7b24e 100644 --- a/gcc/testsuite/g++.dg/ext/is_trivially_constructible1.C +++ b/gcc/testsuite/g++.dg/ext/is_trivially_constructible1.C @@ -48,7 +48,9 @@ SA(!__is_trivially_constructible(int*, const int*)); SA(!__is_trivially_constructible(D)); SA(__is_trivially_copyable(int)); -SA(!__is_trivially_copyable(volatile int)); +// Changed in CWG 2094, which made volatile-qualified scalars trivially +// copyable. +SA(__is_trivially_copyable(volatile int)); struct E1 {const int val;}; SA(__is_trivially_copyable(E1)); diff --git a/gcc/testsuite/g++.dg/ext/is_trivially_copyable.C b/gcc/testsuite/g++.dg/ext/is_trivially_copyable.C new file mode 100644 index 00000000000..6f93602c8c2 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/is_trivially_copyable.C @@ -0,0 +1,16 @@ +// CWG 2094 - volatile scalars are trivially copyable. +// PR c++/85679 +// { dg-do compile { target c++11 } } + +#define SA(X) static_assert((X),#X) + +struct S{}; + +SA(__is_trivially_copyable(S volatile)); +SA(__is_trivially_copyable(S volatile[])); +SA(__is_trivially_copyable(S const volatile)); +SA(__is_trivially_copyable(S const volatile[])); +SA(__is_trivially_copyable(int volatile)); +SA(__is_trivially_copyable(int volatile[])); +SA(__is_trivially_copyable(int const volatile)); +SA(__is_trivially_copyable(int const volatile[])); diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 98a676ec5c0..19ba2355c43 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,10 @@ +2019-05-20 Marek Polacek + + CWG 2094 - volatile scalars are trivially copyable. + PR c++/85679 + * testsuite/20_util/is_trivially_copyable/value.cc: Change the expected + result for volatile int. + 2019-05-20 Jonathan Wakely * testsuite/17_intro/names.cc: Do not check 'ptr' on Solaris. diff --git a/libstdc++-v3/testsuite/20_util/is_trivially_copyable/value.cc b/libstdc++-v3/testsuite/20_util/is_trivially_copyable/value.cc index cce620daf4d..022f0c0b248 100644 --- a/libstdc++-v3/testsuite/20_util/is_trivially_copyable/value.cc +++ b/libstdc++-v3/testsuite/20_util/is_trivially_copyable/value.cc @@ -46,8 +46,10 @@ void test01() static_assert(test_property(true), ""); + // Changed in CWG 2094, which made volatile-qualified scalars trivially + // copyable. static_assert(test_property(false), ""); + volatile int>(true), ""); static_assert(test_property(true), ""); static_assert(test_property