diff options
Diffstat (limited to 'gcc/testsuite')
34 files changed, 1096 insertions, 3 deletions
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index d536a14593a..0ea0587a702 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,208 @@ +2017-06-09 Janus Weil <janus@gcc.gnu.org> + + Backport from trunk + PR fortran/70601 + * gfortran.dg/proc_ptr_comp_50.f90: New test. + +2017-06-08 Jakub Jelinek <jakub@redhat.com> + + PR c/81006 + * c-c++-common/gomp/pr81006.c: New test. + + PR c++/81011 + * g++.dg/gomp/pr81011.C: New test. + +2017-06-06 David S. Miller <davem@davemloft.net> + + * gcc.target/sparc/sparc-ret-3.c: New test. + +2017-06-06 Toma Tabacu <toma.tabacu@imgtec.com> + + Backported from mainline + 2017-03-09 Toma Tabacu <toma.tabacu@imgtec.com> + + * g++.dg/lto/pr69589_0.C: Add dg-require-effective-target for + rdynamic. + * lib/target-supports.exp (check_effective_target_rdynamic): + New proc. + +2017-05-03 Thomas Koenig <tkoenig@gcc.gnu.org> + + PR fortran/65542 + Backport from trunk + * gfortran.dg/spread_init_expr_2.f90: New test case. + +2017-06-02 Thomas Koenig <tkoenig@gcc.gnu.org> + + PR fortran/80904 + Backport from trunk + * gfortran.dg/matmul_bounds_12.f90: New test. + +2017-05-26 Martin Liska <mliska@suse.cz> + + Backport from mainline + 2017-04-24 Martin Liska <mliska@suse.cz> + + PR middle-end/79931 + * g++.dg/ipa/pr79931.C: New test. + +2017-05-26 Martin Liska <mliska@suse.cz> + + Backport from mainline + 2017-04-11 Martin Liska <mliska@suse.cz> + + PR ipa/80212 + * g++.dg/ipa/pr80212.C: New test. + +2017-05-26 Martin Liska <mliska@suse.cz> + + Backport from mainline + 2017-04-11 Martin Liska <mliska@suse.cz> + + PR sanitizer/70878 + * gcc.dg/ubsan/pr70878.c: New test. + +2017-05-26 Martin Liska <mliska@suse.cz> + + Backport from mainline + 2017-04-10 Martin Liska <mliska@suse.cz> + + PR sanitizer/80350 + * c-c++-common/ubsan/pr80350.c: New test. + +2017-05-26 Martin Liska <mliska@suse.cz> + + Backport from mainline + 2017-04-06 Martin Liska <mliska@suse.cz> + + PR sanitizer/80166 + * gcc.dg/asan/pr80166.c: New test. + +2017-05-26 Martin Liska <mliska@suse.cz> + + Backport from mainline + 2017-03-28 Martin Liska <mliska@suse.cz> + + PR ipa/80205 + * g++.dg/ipa/pr80205.C: New test. + +2017-05-26 Martin Liska <mliska@suse.cz> + + Backport from mainline + 2017-03-28 Martin Liska <mliska@suse.cz> + + PR ipa/80104 + * gcc.dg/ipa/pr80104.c: New test. + +2017-05-23 Sheldon Lobo <sheldon.lobo@oracle.com> + + Backport from mainline + 2017-05-18 Sheldon Lobo <sheldon.lobo@oracle.com> + + * gcc.target/sparc/niagara7-align.c: New test. + +2017-05-22 Bill Schmidt <wschmidt@linux.vnet.ibm.com> + + Backport from mainline + 2017-05-22 Bill Schmidt <wschmidt@linux.vnet.ibm.com> + + * gcc.target/powerpc/p8-vec-xl-xst.c: Fix target string to + LE-only. + +2017-05-19 Uros Bizjak <ubizjak@gmail.com> + + Backport from mainline + 2017-05-18 Uros Bizjak <ubizjak@gmail.com> + + PR target/80799 + * g++.dg/other/i386-11.C: New test. + +2017-05-15 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/80752 + * gfortran.dg/pr80752.f90: New test. + +2017-05-15 Richard Biener <rguenther@suse.de> + + Revert backport of + PR middle-end/80222 + * g++.dg/pr80222.C: New testcase. + +2017-05-13 Bill Schmidt <wschmidt@linux.vnet.ibm.com> + + Backport from mainline + 2017-05-05 Bill Schmidt <wschmidt@linux.vnet.ibm.com> + + * gcc.target/powerpc/versioned-copy-loop.c: New file. + +2017-05-12 Bill Schmidt <wschmidt@linux.vnet.ibm.com> + + Backport from mainline + 2017-05-10 Bill Schmidt <wschmidt@linux.vnet.ibm.com> + + * gcc.target/powerpc/p8-vec-xl-xst.c: New file. + +2017-05-10 Richard Biener <rguenther@suse.de> + + Backport from mainline + 2017-03-17 Richard Biener <rguenther@suse.de> + + PR middle-end/80075 + * g++.dg/torture/pr80075.C: New testcase. + + 2017-03-21 Richard Biener <rguenther@suse.de> + + PR tree-optimization/80122 + * gcc.dg/torture/pr80122.c: New testcase. + + 2017-03-24 Richard Biener <rguenther@suse.de> + + PR tree-optimization/80167 + * gcc.dg/graphite/pr80167.c: New testcase. + + 2017-03-27 Richard Biener <rguenther@suse.de> + + PR middle-end/80171 + * g++.dg/torture/pr80171.C: New testcase. + +2017-05-09 Richard Biener <rguenther@suse.de> + + Backport from mainline + 2017-03-28 Richard Biener <rguenther@suse.de> + + PR middle-end/80222 + * g++.dg/pr80222.C: New testcase. + + 2017-04-06 Richard Biener <rguenther@suse.de> + + PR tree-optimization/80262 + * gcc.target/i386/pr80262.c: New testcase. + + 2017-04-03 Richard Biener <rguenther@suse.de> + + PR tree-optimization/80275 + * g++.dg/opt/pr80275.C: New testcase. + + 2017-04-06 Richard Biener <rguenther@suse.de> + + PR tree-optimization/80334 + * g++.dg/torture/pr80334.C: New testcase. + + 2017-04-10 Richard Biener <rguenther@suse.de> + + PR middle-end/80362 + * gcc.dg/torture/pr80362.c: New testcase. + + 2017-04-25 Richard Biener <rguenther@suse.de> + + PR tree-optimization/80492 + * gcc.dg/pr80492.c: New testcase. + + 2017-04-27 Richard Biener <rguenther@suse.de> + + PR middle-end/80539 + * gcc.dg/torture/pr80539.c: New testcase. + 2017-05-09 Jakub Jelinek <jakub@redhat.com> PR testsuite/80678 @@ -183,8 +388,8 @@ Backport from mainline 2017-03-30 Martin Jambor <mjambor@suse.cz> - PR ipa/77333 - * g++.dg/ipa/pr77333.C: New test. + PR ipa/77333 + * g++.dg/ipa/pr77333.C: New test. 2017-04-06 Uros Bizjak <ubizjak@gmail.com> diff --git a/gcc/testsuite/c-c++-common/gomp/pr81006.c b/gcc/testsuite/c-c++-common/gomp/pr81006.c new file mode 100644 index 00000000000..a826c5f5a53 --- /dev/null +++ b/gcc/testsuite/c-c++-common/gomp/pr81006.c @@ -0,0 +1,10 @@ +/* PR c/81006 */ +/* { dg-do compile } */ + +int a[] = {}; + +void foo() +{ + #pragma omp task depend(out: a[:]) /* { dg-error "zero length array section in .depend. clause" } */ + {} +} diff --git a/gcc/testsuite/c-c++-common/ubsan/pr80350.c b/gcc/testsuite/c-c++-common/ubsan/pr80350.c new file mode 100644 index 00000000000..317d2facaf7 --- /dev/null +++ b/gcc/testsuite/c-c++-common/ubsan/pr80350.c @@ -0,0 +1,17 @@ +/* PR target/80310 */ +/* { dg-do run } */ +/* { dg-options "-O0 -fsanitize=shift -fno-sanitize-recover=shift" } */ + +unsigned int x = 1; +unsigned int y = 0; + +void foo() { + y = 1 >> (!x * 1111); +} + +int main () { + foo (); + if (y != 1) + __builtin_abort (); + return 0; +} diff --git a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-nested6.C b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-nested6.C new file mode 100644 index 00000000000..58dfe3c908f --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-nested6.C @@ -0,0 +1,12 @@ +// PR c++/80267 +// { dg-do compile { target c++11 } } + +template <typename> void a() { + int b; + auto &c = b; + [&] { + c; + [&] { c; }; + }; +} +void d() { a<int>(); } diff --git a/gcc/testsuite/g++.dg/cpp1y/constexpr-empty3.C b/gcc/testsuite/g++.dg/cpp1y/constexpr-empty3.C new file mode 100644 index 00000000000..37e4a53a7a9 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1y/constexpr-empty3.C @@ -0,0 +1,14 @@ +// PR c++/80294 +// { dg-do compile { target c++14 } } +// { dg-final { scan-assembler-not "static_init" } } + +struct A { + constexpr int f() { A a = *this; return 42; } +}; +struct B: A +{ + int i; + constexpr B(): i(f()) {} +}; + +B b; diff --git a/gcc/testsuite/g++.dg/ext/flexary24.C b/gcc/testsuite/g++.dg/ext/flexary24.C new file mode 100644 index 00000000000..c25e540243a --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/flexary24.C @@ -0,0 +1,12 @@ +// PR c++/80179 +// { dg-options "" } + +struct S { + int n; + const char *a[]; +}; + +void bar (const char *a) +{ + static const S t = { 1, { a, "b" } }; +} diff --git a/gcc/testsuite/g++.dg/gomp/pr81011.C b/gcc/testsuite/g++.dg/gomp/pr81011.C new file mode 100644 index 00000000000..4abd609596c --- /dev/null +++ b/gcc/testsuite/g++.dg/gomp/pr81011.C @@ -0,0 +1,19 @@ +// PR c++/81011 +// { dg-do compile } + +class A { A (const A&); }; // { dg-message "declared private here" } +void foo (const A&); + +void +bar (A& a) +{ +#pragma omp task // { dg-error "is private within this context" } + foo (a); +} + +void +baz (A& a) +{ +#pragma omp task firstprivate (a) // { dg-error "is private within this context" } + foo (a); +} diff --git a/gcc/testsuite/g++.dg/ipa/pr79931.C b/gcc/testsuite/g++.dg/ipa/pr79931.C new file mode 100644 index 00000000000..78f6e03c458 --- /dev/null +++ b/gcc/testsuite/g++.dg/ipa/pr79931.C @@ -0,0 +1,24 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-ipa-all" } */ + +class DocumentImpl; +struct NodeImpl +{ + virtual DocumentImpl * getOwnerDocument(); + virtual NodeImpl * getParentNode(); + virtual NodeImpl * removeChild(NodeImpl *oldChild); +}; +struct AttrImpl : NodeImpl +{ + NodeImpl *insertBefore(NodeImpl *newChild, NodeImpl *refChild); +}; +struct DocumentImpl : NodeImpl +{ + virtual NodeImpl *removeChild(NodeImpl *oldChild); + virtual int* getRanges(); +}; +NodeImpl *AttrImpl::insertBefore(NodeImpl *newChild, NodeImpl *refChild) { + NodeImpl *oldparent = newChild->getParentNode(); + oldparent->removeChild(newChild); + this->getOwnerDocument()->getRanges(); +} diff --git a/gcc/testsuite/g++.dg/ipa/pr80205.C b/gcc/testsuite/g++.dg/ipa/pr80205.C new file mode 100644 index 00000000000..460bdcb02ca --- /dev/null +++ b/gcc/testsuite/g++.dg/ipa/pr80205.C @@ -0,0 +1,34 @@ +// PR ipa/80205 +// { dg-options "-fnon-call-exceptions --param early-inlining-insns=100 -O2" } + +class a +{ +public: + virtual ~a (); +}; +class b +{ +public: + template <typename c> b (c); + ~b () { delete d; } + void + operator= (b e) + { + b (e).f (*this); + } + void + f (b &e) + { + a g; + d = e.d; + e.d = &g; + } + a *d; +}; +void +h () +{ + b i = int(); + void j (); + i = j; +} diff --git a/gcc/testsuite/g++.dg/ipa/pr80212.C b/gcc/testsuite/g++.dg/ipa/pr80212.C new file mode 100644 index 00000000000..60d3b613035 --- /dev/null +++ b/gcc/testsuite/g++.dg/ipa/pr80212.C @@ -0,0 +1,18 @@ +// PR ipa/80212 +// { dg-options "-O2 --param partial-inlining-entry-probability=403796683 -fno-early-inlining" } + +struct b +{ + virtual b *c () const; +}; +struct d : virtual b +{ +}; +struct e : d +{ + e * + c () const + { + } +}; +main () { e a; } diff --git a/gcc/testsuite/g++.dg/lto/pr69589_0.C b/gcc/testsuite/g++.dg/lto/pr69589_0.C index 1457d2eb13e..599d5d44960 100644 --- a/gcc/testsuite/g++.dg/lto/pr69589_0.C +++ b/gcc/testsuite/g++.dg/lto/pr69589_0.C @@ -1,7 +1,7 @@ // { dg-lto-do link } // { dg-lto-options "-O2 -rdynamic" } // { dg-extra-ld-options "-r -nostdlib" } -// { dg-skip-if "Skip targets without -rdynamic support" { arm*-none-eabi aarch64*-*-elf } { "*" } { "" } } +// { dg-require-effective-target rdynamic } #pragma GCC visibility push(hidden) struct A { int &operator[] (long); }; diff --git a/gcc/testsuite/g++.dg/opt/pr80275.C b/gcc/testsuite/g++.dg/opt/pr80275.C new file mode 100644 index 00000000000..7296a07fb2d --- /dev/null +++ b/gcc/testsuite/g++.dg/opt/pr80275.C @@ -0,0 +1,16 @@ +// { dg-do compile { target c++14 } } +// { dg-options "-O2 -fdump-tree-optimized" } + +#include <algorithm> + +int g() +{ + return 1234; +} + +int f2() +{ + return std::min({1, g(), 4}); +} + +// { dg-final { scan-tree-dump "return 1;" "optimized" } } diff --git a/gcc/testsuite/g++.dg/other/i386-11.C b/gcc/testsuite/g++.dg/other/i386-11.C new file mode 100644 index 00000000000..8e06617fca5 --- /dev/null +++ b/gcc/testsuite/g++.dg/other/i386-11.C @@ -0,0 +1,57 @@ +// PR target/80799 +// { dg-do compile { target i?86-*-* x86_64-*-* } } +// { dg-require-effective-target c++11 } +// { dg-options "-O2 -msse2" } + +#include <xmmintrin.h> +#include <emmintrin.h> + +class alignas(16) GSVector4i +{ +public: + __m128i m; + + explicit GSVector4i(__m128i m) + { + this->m = m; + } + + static void storel(void* p, const GSVector4i& v) + { + _mm_storel_epi64((__m128i*)p, v.m); + } + + static GSVector4i loadl(const void* p) + { + return GSVector4i(_mm_loadl_epi64((__m128i*)p)); + } + + bool eq(const GSVector4i& v) const + { + return _mm_movemask_epi8(_mm_cmpeq_epi32(m, v.m)) == 0xffff; + } +}; + + +union GIFRegTRXPOS +{ + unsigned long long u64; + void operator = (const GSVector4i& v) {GSVector4i::storel(this, v);} + bool operator != (const union GIFRegTRXPOS& r) const {return !((GSVector4i)r).eq(*this);} + operator GSVector4i() const {return GSVector4i::loadl(this);} +}; + +extern void dummy_call(); +extern GIFRegTRXPOS TRXPOS; + +void GIFRegHandlerTRXPOS(const GIFRegTRXPOS& p) +{ + if(p != TRXPOS) + { + dummy_call(); + } + + TRXPOS = (GSVector4i)p; +} + +// { dg-final { scan-assembler-not "%mm" } } diff --git a/gcc/testsuite/g++.dg/torture/pr80075.C b/gcc/testsuite/g++.dg/torture/pr80075.C new file mode 100644 index 00000000000..5bc802027c0 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr80075.C @@ -0,0 +1,27 @@ +// { dg-do compile } +// { dg-additional-options "-fnon-call-exceptions" } + +struct s { + int i; +}; + +extern int use_memcpy; +extern void my_memcpy(void*, void*, int); + +int +f (struct s* p) +{ + struct s a; + + try + { + a = (struct s){}; + if (!use_memcpy) + *p = a; + else + my_memcpy (p, &a, sizeof (struct s)); + } catch (...) { + return 0; + } + return 1; +} diff --git a/gcc/testsuite/g++.dg/torture/pr80171.C b/gcc/testsuite/g++.dg/torture/pr80171.C new file mode 100644 index 00000000000..81f272583c5 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr80171.C @@ -0,0 +1,183 @@ +// { dg-do compile } + +template <typename> struct remove_reference; +template <typename _Tp> struct remove_reference<_Tp &> { typedef _Tp type; }; +template <typename _Tp> typename remove_reference<_Tp>::type move(_Tp &&p1) { + return static_cast<typename remove_reference<_Tp>::type &&>(p1); +} +void *operator new(__SIZE_TYPE__, void *p2) { return p2; } +struct Trans_NS__v1_GenericTlv { + virtual int getMinimumValueLength(); + virtual unsigned long getValueLength() const; +}; +struct IPv4NeighborAddressSubTlv; +struct Trans_NS__v1_GenericTlvBase : Trans_NS__v1_GenericTlv { + virtual bool operator==(const IPv4NeighborAddressSubTlv &) const; +}; +struct Trans_NS__v1_GenericUnsupportedTlv; +template <typename> struct backup_holder { + Trans_NS__v1_GenericUnsupportedTlv *backup_; + Trans_NS__v1_GenericUnsupportedTlv &get() { return *backup_; } +}; +template <typename> struct make_reference_content { + typedef IPv4NeighborAddressSubTlv type; +}; +template <typename> struct unwrap_recursive { + typedef IPv4NeighborAddressSubTlv type; +}; +template <typename> struct begin_impl; +template <typename Sequence> struct begin { + typedef typename Sequence::tag tag_; + typedef typename begin_impl<tag_>::template apply<Sequence>::type type; +}; +struct long_ { + static const int value = 0; +}; +template <typename> struct O1_size_impl; +template <typename Sequence> +struct O1_size + : O1_size_impl<typename Sequence::tag>::template apply<Sequence> {}; +template <typename F, typename T2> +struct apply_wrap2 : F::template apply<int, T2> {}; +template <int, typename, typename> struct iter_fold_impl; +template <typename First, typename ForwardOp> +struct iter_fold_impl<0, First, ForwardOp> { + typedef typename apply_wrap2<ForwardOp, First>::type state; +}; +template <typename Sequence, typename ForwardOp> struct iter_fold { + typedef + typename iter_fold_impl<O1_size<Sequence>::value, + typename begin<Sequence>::type, ForwardOp>::state + type; +}; +template <typename> struct deref; +template <typename T1> struct pair { typedef T1 first; }; +struct make_initializer_node { + template <typename, typename Iterator> struct apply { + struct initializer_node { + typedef typename deref<Iterator>::type recursive_enabled_T; + static int + initialize(void *p1, + typename unwrap_recursive<recursive_enabled_T>::type) { + new (p1) typename make_reference_content<recursive_enabled_T>::type; + } + }; + typedef pair<initializer_node> type; + }; +}; +struct l_item { + typedef int tag; + typedef l_item type; + typedef long_ size; + typedef int item; +}; +template <> struct O1_size_impl<int> { + template <typename List> struct apply : List::size {}; +}; +template <typename> struct l_iter; +template <typename Node> struct deref<l_iter<Node>> { + typedef typename Node::item type; +}; +template <> struct begin_impl<int> { + template <typename List> struct apply { + typedef l_iter<typename List::type> type; + }; +}; +template <typename, typename, typename, typename, typename, typename, typename> +struct list : l_item {}; +template <typename... T> struct make_variant_list { typedef list<T...> type; }; +template <typename T> T cast_storage(void *p1) { return *static_cast<T *>(p1); } +struct visitation_impl_step { + typedef Trans_NS__v1_GenericUnsupportedTlv type; +}; +template <typename Visitor, typename VoidPtrCV, typename T> +void visitation_impl_invoke_impl(Visitor p1, VoidPtrCV p2, T *) { + backup_holder<Trans_NS__v1_GenericUnsupportedTlv> __trans_tmp_8 = + cast_storage<backup_holder<T>>(p2); + p1.internal_visit(__trans_tmp_8, 0); +} +template <typename Visitor, typename VoidPtrCV, typename T, + typename NoBackupFlag> +void visitation_impl_invoke(Visitor p1, VoidPtrCV p2, T p3, NoBackupFlag) { + visitation_impl_invoke_impl(p1, p2, p3); +} +template <typename Which, typename step0, typename Visitor, typename VoidPtrCV, + typename NoBackupFlag> +void visitation_impl(Visitor p1, VoidPtrCV p2, NoBackupFlag, Which, step0 *) { + visitation_impl_invoke(p1, p2, static_cast<typename step0::type *>(0), 0); +} +struct move_into { + move_into(void *); + template <typename T> void internal_visit(backup_holder<T> p1, int) { + T __trans_tmp_2 = p1.get(); + new (0) T(__trans_tmp_2); + } +}; +template <typename, typename... TN> struct variant { + struct initializer : iter_fold<typename make_variant_list<int, TN...>::type, + make_initializer_node>::type::first {}; + template <typename T> void convert_construct(T p1, int) { + void *__trans_tmp_9 = this; + initializer::initialize(__trans_tmp_9, p1); + } + template <typename T> variant(T p1) { convert_construct(p1, 0); } + variant(variant &&p1) { + move_into visitor(0); + p1.internal_apply_visitor(visitor); + } + template <typename Visitor> void internal_apply_visitor(Visitor p1) { + void *__trans_tmp_10 = this; + visitation_impl(p1, __trans_tmp_10, 0, 0, + static_cast<visitation_impl_step *>(0)); + } +}; +template <class...> struct generic_element_tlvs; +template <typename TlvConfig, class UnsupportedTlvClass, class TlvF, + class... TlvR> +struct generic_element_tlvs<TlvConfig, UnsupportedTlvClass, TlvF, TlvR...> { + typedef variant<UnsupportedTlvClass, TlvF, TlvR...> variant_type; +}; +template <typename, typename> struct Trans_NS__v1_GenericTlvContainer { + template <class TlvClass> void addTlv(const TlvClass &); +}; +template <typename TlvConfig, typename ElementTlvs> +template <class TlvClass> +void Trans_NS__v1_GenericTlvContainer<TlvConfig, ElementTlvs>::addTlv( + const TlvClass &p1) { + typename ElementTlvs::variant_type wrap(p1); + move(wrap); +} +template <typename ElementTlvs> +struct Trans_NS__v1_GenericContainerEntryBase + : Trans_NS__v1_GenericTlvContainer<int, ElementTlvs> {}; +template <class> +struct Trans_NS__v1_GenericFixedLengthTlvBase : Trans_NS__v1_GenericTlvBase { + unsigned long getValueLength() const; +}; +struct Trans_NS__v1_GenericUnsupportedTlv : Trans_NS__v1_GenericTlv { + long getHeaderLengthconst; +}; +using isis_tlv_config = int; +template <class... TlvClasses> +using isis_element_tlvs = + generic_element_tlvs<isis_tlv_config, Trans_NS__v1_GenericUnsupportedTlv, + TlvClasses...>; +template <int, class, typename ElementTlvs> +using ContainerEntryBase = Trans_NS__v1_GenericContainerEntryBase<ElementTlvs>; +template <int, class ImplClass, int> +using FixedLengthTlvBase = Trans_NS__v1_GenericFixedLengthTlvBase<ImplClass>; +struct IPv4NeighborAddressSubTlv + : FixedLengthTlvBase<0, IPv4NeighborAddressSubTlv, 0> { + bool operator==(const IPv4NeighborAddressSubTlv &) const; +}; +void test() { + ContainerEntryBase< + 0, int, + isis_element_tlvs< + FixedLengthTlvBase<0, int, 0>, FixedLengthTlvBase<0, int, 0>, + IPv4NeighborAddressSubTlv, FixedLengthTlvBase<0, int, 0>, + FixedLengthTlvBase<0, int, 0>, FixedLengthTlvBase<0, int, 0>>> + isEntry; + IPv4NeighborAddressSubTlv nbAddressSubTlv; + isEntry.addTlv(nbAddressSubTlv); +} diff --git a/gcc/testsuite/g++.dg/torture/pr80334.C b/gcc/testsuite/g++.dg/torture/pr80334.C new file mode 100644 index 00000000000..aee15487636 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr80334.C @@ -0,0 +1,18 @@ +// { dg-do run } + +struct A { alignas(16) char c; }; +struct B { A unpacked; char d; } __attribute__((packed)); + +char x; + +int +main() +{ + alignas(__BIGGEST_ALIGNMENT__) B b[3]; + for (int i = 0; i < 3; i++) b[i].unpacked.c = 'a' + i; + for (int i = 0; i < 3; i++) + { + auto a = new A(b[i].unpacked); + x = a->c; + } +} diff --git a/gcc/testsuite/gcc.dg/asan/pr80166.c b/gcc/testsuite/gcc.dg/asan/pr80166.c new file mode 100644 index 00000000000..629dd23a31c --- /dev/null +++ b/gcc/testsuite/gcc.dg/asan/pr80166.c @@ -0,0 +1,24 @@ +/* PR sanitizer/80166 */ +/* { dg-do run } */ + +#include <sys/types.h> +#include <unistd.h> + +int +main (int argc, char **argv) +{ + gid_t groups; + int r = getgroups (0, &groups); + if (r < 0) + __builtin_abort (); + + r = getgroups (-1, &groups); + if (r != -1) + __builtin_abort (); + + r = getgroups (-1, NULL); + if (r != -1) + __builtin_abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.dg/graphite/pr80167.c b/gcc/testsuite/gcc.dg/graphite/pr80167.c new file mode 100644 index 00000000000..990450b2ae6 --- /dev/null +++ b/gcc/testsuite/gcc.dg/graphite/pr80167.c @@ -0,0 +1,24 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -floop-nest-optimize" } */ + +typedef struct +{ + short a; + short b; + short c; +} d; +extern d e[]; +int f[8]; +void +g (d *i) +{ + int h = 0; + for (; h < 28; h++) + e[h].a = e[h].b = i[h].a; + h = 0; + for (; h < 8; h++) + f[h] = i[h].b + i[h].c; + h = 0; + for (; h < 8; h++) + f[h] = i[h].b; +} diff --git a/gcc/testsuite/gcc.dg/ipa/pr80104.c b/gcc/testsuite/gcc.dg/ipa/pr80104.c new file mode 100644 index 00000000000..7e75c9907e7 --- /dev/null +++ b/gcc/testsuite/gcc.dg/ipa/pr80104.c @@ -0,0 +1,15 @@ +/* PR ipa/80104 */ +/* { dg-do compile } */ +/* { dg-options "-fipa-icf" } */ + +float +a (_Complex float b) +{ + return *&b; +} + +float +c (_Complex float b) +{ + return (&b)[0]; +} diff --git a/gcc/testsuite/gcc.dg/pr80492.c b/gcc/testsuite/gcc.dg/pr80492.c new file mode 100644 index 00000000000..1721b2dee39 --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr80492.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-options "-w -O2 -fdump-tree-optimized" } */ + +static __inline__ __attribute__((__always_inline__)) +void syscall_7 (int val) +{ + register int reg __asm ("4") = val; + __asm __volatile__ ("/* Some Code %0 */" :: "r" (reg)); +} + +void do_syscalls (void) +{ + for (int s = 0; s < 2; s++) + { + syscall_7 (0); + syscall_7 (1); + } +} + +/* { dg-final { scan-tree-dump-times "reg = " 4 "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/torture/pr80122.c b/gcc/testsuite/gcc.dg/torture/pr80122.c new file mode 100644 index 00000000000..a76d756c32e --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr80122.c @@ -0,0 +1,52 @@ +/* { dg-do run } */ + +#define __GNU_ALWAYS_INLINE inline __attribute__(( __always_inline__)) + +#define DEVT_ALL 0 + +#define CMD_ABI_DEVICES 100 + +static __GNU_ALWAYS_INLINE int +send_msg_to_gm_w_dev_t(int msg_type, unsigned int dev_msg_type, + int devt, ...) +{ + char s[256]; + int nArgs = __builtin_va_arg_pack_len(); + if (nArgs != 2) + __builtin_abort (); + __builtin_sprintf (s, "%d", __builtin_va_arg_pack ()); + if (__builtin_strcmp (s, "99") != 0) + __builtin_abort (); + /* do something with nArgs and ... */ + return 0; +} + +static __GNU_ALWAYS_INLINE int +send_msg_to_gm(int msg_type, unsigned int dev_msg_type, + ...) +{ + int nArgs = __builtin_va_arg_pack_len(); + if (nArgs != 2) + __builtin_abort (); + return send_msg_to_gm_w_dev_t(msg_type, dev_msg_type, + DEVT_ALL, __builtin_va_arg_pack()); +} + +static __GNU_ALWAYS_INLINE int +send_enable(unsigned int dev_msg_type, ...) +{ + int nArgs = __builtin_va_arg_pack_len(); + if (nArgs != 2) + __builtin_abort (); + return send_msg_to_gm(CMD_ABI_DEVICES, dev_msg_type, __builtin_va_arg_pack()); +} + +int +main(void) +{ + int mode = 99; + + send_enable(1, mode, sizeof(mode)); + + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/pr80362.c b/gcc/testsuite/gcc.dg/torture/pr80362.c new file mode 100644 index 00000000000..6d22eb040ad --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr80362.c @@ -0,0 +1,10 @@ +/* { dg-do run } */ +/* { dg-additional-options "-fstrict-overflow" } */ + +int main() +{ + signed char var_0, var_1 = -128; + var_0 = (signed char)(-var_1) / 3; + if (var_0 > 0) + __builtin_abort(); +} diff --git a/gcc/testsuite/gcc.dg/torture/pr80539.c b/gcc/testsuite/gcc.dg/torture/pr80539.c new file mode 100644 index 00000000000..a66767814d3 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr80539.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ + +signed char a, b; +void fn1() +{ + signed char c, e; + short d; + if (0) { + for (; d;) { +l1: + for (c = 7; a; c++) + ; + e = 6; + for (; b; e++) + ; + } + c -= e; + } + if (d == 7) + goto l1; + a = c; +} diff --git a/gcc/testsuite/gcc.dg/ubsan/pr70878.c b/gcc/testsuite/gcc.dg/ubsan/pr70878.c new file mode 100644 index 00000000000..acd7fb05e4c --- /dev/null +++ b/gcc/testsuite/gcc.dg/ubsan/pr70878.c @@ -0,0 +1,9 @@ +/* PR sanitizer/80878 */ +/* { dg-do compile { target { { i?86-*-* x86_64-*-* } && lp64 } } } */ +/* { dg-options "-fsanitize=object-size" } */ + +void * sbrk () +{ + volatile register unsigned int sp_r1 __asm__ ("ebx"); + return __builtin_strcat ((char*)sp_r1, 0); /* { dg-warning "cast to pointer from integer of different size" } */ +} diff --git a/gcc/testsuite/gcc.target/i386/pr80262.c b/gcc/testsuite/gcc.target/i386/pr80262.c new file mode 100644 index 00000000000..140edfea53c --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr80262.c @@ -0,0 +1,26 @@ +/* { dg-do compile } */ +/* { dg-options "-O2" } */ + +typedef struct { + int v; +} S1; +S1 clearS1 () { S1 s1 = { 0 }; return s1; } + +typedef struct { + S1 s1[4]; +} S2; +void clearS2 (__seg_gs S2* p, int n) { + for (int i = 0; i < n; ++i) + p->s1[i] = clearS1 (); +} + +typedef struct { + int pad; + S2 s2; +} S3; + +long int BASE; + +void fn1(int n) { + clearS2 (&(((__seg_gs S3*)(BASE))->s2), n); +} diff --git a/gcc/testsuite/gcc.target/powerpc/p8-vec-xl-xst.c b/gcc/testsuite/gcc.target/powerpc/p8-vec-xl-xst.c new file mode 100644 index 00000000000..d9dc641de77 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/p8-vec-xl-xst.c @@ -0,0 +1,62 @@ +/* { dg-do compile { target { powerpc64le-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power8" } } */ +/* { dg-options "-mcpu=power8 -O2" } */ + +/* Verify fix for problem where vec_xl and vec_xst are not recognized + for the vector char and vector short cases on P8 only. */ + +#include <altivec.h> + +vector unsigned char +foo (unsigned char * address) +{ + return __builtin_vec_xl (0, address); +} + +void +bar (vector unsigned char x, unsigned char * address) +{ + __builtin_vec_xst (x, 0, address); +} + +vector unsigned short +foot (unsigned short * address) +{ + return __builtin_vec_xl (0, address); +} + +void +bart (vector unsigned short x, unsigned short * address) +{ + __builtin_vec_xst (x, 0, address); +} + +vector unsigned char +fool (unsigned char * address) +{ + return vec_xl (0, address); +} + +void +barl (vector unsigned char x, unsigned char * address) +{ + vec_xst (x, 0, address); +} + +vector unsigned short +footle (unsigned short * address) +{ + return vec_xl (0, address); +} + +void +bartle (vector unsigned short x, unsigned short * address) +{ + vec_xst (x, 0, address); +} + +/* { dg-final { scan-assembler-times "lxvd2x" 4 } } */ +/* { dg-final { scan-assembler-times "stxvd2x" 4 } } */ +/* { dg-final { scan-assembler-times "xxpermdi" 8 } } */ diff --git a/gcc/testsuite/gcc.target/powerpc/versioned-copy-loop.c b/gcc/testsuite/gcc.target/powerpc/versioned-copy-loop.c new file mode 100644 index 00000000000..bbfd1652e5e --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/versioned-copy-loop.c @@ -0,0 +1,30 @@ +/* { dg-do compile } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-O3 -fdump-tree-vect-details" } */ + +/* Verify that a pure copy loop with a vectorization factor of two + that requires alignment will not be vectorized. See the cost + model hooks in rs6000.c. */ + +typedef long unsigned int size_t; +typedef unsigned char uint8_t; + +extern void *memcpy (void *__restrict __dest, const void *__restrict __src, + size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); + +void foo (void *dstPtr, const void *srcPtr, void *dstEnd) +{ + uint8_t *d = (uint8_t*)dstPtr; + const uint8_t *s = (const uint8_t*)srcPtr; + uint8_t* const e = (uint8_t*)dstEnd; + + do + { + memcpy (d, s, 8); + d += 8; + s += 8; + } + while (d < e); +} + +/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" } } */ diff --git a/gcc/testsuite/gcc.target/sparc/niagara7-align.c b/gcc/testsuite/gcc.target/sparc/niagara7-align.c new file mode 100644 index 00000000000..a46aac17c32 --- /dev/null +++ b/gcc/testsuite/gcc.target/sparc/niagara7-align.c @@ -0,0 +1,4 @@ +/* { dg-do compile } */ +/* { dg-options "-falign-functions -mcpu=niagara7" } */ +/* { dg-final { scan-assembler "\.align 64" } } */ +void foo(void) {} diff --git a/gcc/testsuite/gcc.target/sparc/sparc-ret-3.c b/gcc/testsuite/gcc.target/sparc/sparc-ret-3.c new file mode 100644 index 00000000000..7a151f80b42 --- /dev/null +++ b/gcc/testsuite/gcc.target/sparc/sparc-ret-3.c @@ -0,0 +1,53 @@ +/* PR target/80968 */ +/* { dg-do compile } */ +/* { dg-skip-if "no register windows" { *-*-* } { "-mflat" } { "" } } */ +/* { dg-require-effective-target ilp32 } */ +/* { dg-options "-mcpu=ultrasparc -O" } */ + +/* Make sure references to the stack frame do not slip into the delay slot + of a return instruction. */ + +struct crypto_shash { + unsigned int descsize; +}; +struct crypto_shash *tfm; + +struct shash_desc { + struct crypto_shash *tfm; + unsigned int flags; + + void *__ctx[] __attribute__((aligned(8))); +}; + +static inline unsigned int crypto_shash_descsize(struct crypto_shash *tfm) +{ + return tfm->descsize; +} + +static inline void *shash_desc_ctx(struct shash_desc *desc) +{ + return desc->__ctx; +} + +#define SHASH_DESC_ON_STACK(shash, ctx) \ + char __##shash##_desc[sizeof(struct shash_desc) + \ + crypto_shash_descsize(ctx)] __attribute__((aligned(8))); \ + struct shash_desc *shash = (struct shash_desc *)__##shash##_desc + +extern int crypto_shash_update(struct shash_desc *, const void *, unsigned int); + +unsigned int bug(unsigned int crc, const void *address, unsigned int length) +{ + SHASH_DESC_ON_STACK(shash, tfm); + unsigned int *ctx = (unsigned int *)shash_desc_ctx(shash); + int err; + + shash->tfm = tfm; + shash->flags = 0; + *ctx = crc; + + err = crypto_shash_update(shash, address, length); + + return *ctx; +} +/* { dg-final { scan-assembler "ld\[ \t\]*\\\[%i5\\+8\\\], %i0\n\[^\n\]*return\[ \t\]*%i7\\+8" } } */ diff --git a/gcc/testsuite/gfortran.dg/matmul_bounds_12.f90 b/gcc/testsuite/gfortran.dg/matmul_bounds_12.f90 new file mode 100644 index 00000000000..01b3df92c3f --- /dev/null +++ b/gcc/testsuite/gfortran.dg/matmul_bounds_12.f90 @@ -0,0 +1,17 @@ +! { dg-do run } +program main + real, dimension(3,2) :: a + real, dimension(3) :: bp + real, dimension(3) :: res1 + real, dimension(:), allocatable :: c3 + real, dimension(2) :: res2 + + data a /-2., 3., -5., 7., -11., 13./ + data bp /-23., -31., -41./ + data res2 /158., -353./ + + c3 = matmul(bp,a) + if (size(c3,1) /= 2) call abort + if (any(c3 /= res2)) call abort + +end program main diff --git a/gcc/testsuite/gfortran.dg/pr80752.f90 b/gcc/testsuite/gfortran.dg/pr80752.f90 new file mode 100644 index 00000000000..00a4b33d29a --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr80752.f90 @@ -0,0 +1,20 @@ +! { dg-do compile } +! PR fortran/80752 +module exchange_utils + + implicit none + + integer, parameter, public :: knd = 8 + + type, private :: a + logical :: add_vs98 = 0.0_knd ! { dg-error "Can't convert" } + end type a + + type, private :: x_param_t + type(a) :: m05_m06 + end type x_param_t + + type(x_param_t), public, save :: x_param + +end module exchange_utils + diff --git a/gcc/testsuite/gfortran.dg/proc_ptr_comp_50.f90 b/gcc/testsuite/gfortran.dg/proc_ptr_comp_50.f90 new file mode 100644 index 00000000000..d62d8326dd7 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/proc_ptr_comp_50.f90 @@ -0,0 +1,26 @@ +! { dg-do compile } +! +! PR 70601: [5/6/7 Regression] [OOP] ICE on procedure pointer component call +! +! Contributed by zmi <zmi007@gmail.com> + +program test + implicit none + + type :: concrete_type + procedure (run_concrete_type), pointer :: run + end type + + type(concrete_type), allocatable :: concrete + + allocate(concrete) + concrete % run => run_concrete_type + call concrete % run() + +contains + + subroutine run_concrete_type(this) + class(concrete_type) :: this + end subroutine + +end diff --git a/gcc/testsuite/gfortran.dg/spread_init_expr_2.f90 b/gcc/testsuite/gfortran.dg/spread_init_expr_2.f90 new file mode 100644 index 00000000000..19c27fadca8 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/spread_init_expr_2.f90 @@ -0,0 +1,5 @@ +! { dg-do compile } +! { dg-options "-std=f95" } +module bug + integer :: ibug(42) = spread(42, 1, 42) ! { dg-error "invalid in an initialization expression" } +end module diff --git a/gcc/testsuite/lib/target-supports.exp b/gcc/testsuite/lib/target-supports.exp index 92fd529dfa2..c7bec82293a 100644 --- a/gcc/testsuite/lib/target-supports.exp +++ b/gcc/testsuite/lib/target-supports.exp @@ -1438,6 +1438,14 @@ proc check_effective_target_static_libgfortran { } { } "-static"] } +# Return 1 if we can use the -rdynamic option, 0 otherwise. + +proc check_effective_target_rdynamic { } { + return [check_no_compiler_messages rdynamic executable { + int main() { return 0; } + } "-rdynamic"] +} + # Return 1 if cilk-plus is supported by the target, 0 otherwise. proc check_effective_target_cilkplus { } { |