vect: Reset using_select_vl_p before starting over [PR123074].

In the PR we ICE accessing the loop lens in
vect_get_loop_variant_data_ptr_increment when building 510.parest.
This function only gets called when we use SELECT_VL for the loop
control, however during initialization of the loop lens partial
vectors, a prerequisite for SELECT_VL, was false while using_select_vl
was true.  We reset using_partial_vectors when restarting the analysis
after forcing single-lane SLP but don't reset using_select_vl.

This patch resets it as well.

	PR tree-optimization/123074

gcc/ChangeLog:

	* tree-vect-loop.cc: Reset LOOP_VINFO_USING_SELECT_VL_P.

gcc/testsuite/ChangeLog:

	* gcc.target/riscv/rvv/rvv.exp: Include *.C.
	* gcc.target/riscv/rvv/autovec/pr123074.C: New test.

diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr123074.C b/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr123074.C
new file mode 100644 (file)
index 0000000..d203477
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr123074.C
@@ -0,0 +1,124 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -march=rv64gcv_zvl256b -mabi=lp64d -mrvv-vector-bits=zvl -mrvv-max-lmul=m2 -fpermissive -Wno-return-type" } */
+
+namespace std {
+template <typename _Iterator> _Iterator __miter_base(_Iterator);
+template <typename _Default, typename, template <typename> class>
+struct __detector {
+  using type = _Default;
+};
+template <typename _Default, template <typename> class _Op>
+using __detected_or = __detector<_Default, void, _Op>;
+template <typename _Default, template <typename> class _Op>
+using __detected_or_t = typename __detected_or<_Default, _Op>::type;
+template <typename _Tp> class allocator {
+public:
+  typedef _Tp value_type;
+};
+template <typename> struct pointer_traits {
+  template <typename _Up> using rebind = _Up *;
+};
+} // namespace std
+namespace __gnu_cxx {
+template <typename _Iterator, typename> class __normal_iterator {
+public:
+  _Iterator base();
+};
+} // namespace __gnu_cxx
+namespace std {
+template <bool, typename _OutIter, typename _InIter>
+void __assign_one(_OutIter __out, _InIter __in) {
+  *__out = *__in;
+}
+template <bool _IsMove, typename _BI1, typename _BI2>
+__copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) { /* { dg-warning "with no type" "" } */
+  while (__first != __last) {
+    --__last;
+    --__result;
+    __assign_one<_IsMove>(__result, __last);
+  }
+}
+template <bool _IsMove, typename _BI1, typename _BI2>
+__copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result) { /* { dg-warning "with no type" "" } */
+  __copy_move_backward_a2<_IsMove>(__first, __last, __result);
+}
+template <bool _IsMove, typename _II, typename _OI>
+__copy_move_backward_a(_II __first, _II __last, _OI __result) { /* { dg-warning "with no type" "" } */
+  __copy_move_backward_a1<_IsMove>(__first, __last, __result);
+}
+template <typename _BI1, typename _BI2>
+move_backward(_BI1 __first, _BI1 __last, _BI2 __result) { /* { dg-warning "with no type" "" } */
+  __copy_move_backward_a<true>(__first, __miter_base(__last), __result);
+}
+struct __allocator_traits_base {
+  template <typename _Tp> using __pointer = typename _Tp::pointer;
+  template <typename _Tp> using __c_pointer = typename _Tp::const_pointer;
+};
+template <typename _Alloc> struct allocator_traits : __allocator_traits_base {
+  typedef typename _Alloc::value_type value_type;
+  using pointer = __detected_or_t<value_type *, __pointer>;
+  template <template <typename> class, typename _Tp> struct _Ptr {
+    using type = typename pointer_traits<pointer>::rebind<_Tp>;
+  };
+  using const_pointer = typename _Ptr<__c_pointer, value_type>::type;
+};
+} // namespace std
+namespace __gnu_cxx {
+template <typename _Alloc>
+struct __alloc_traits : std::allocator_traits<_Alloc> {};
+} // namespace __gnu_cxx
+namespace std {
+template <typename, typename _Alloc> struct _Vector_base {
+  typedef __gnu_cxx::__alloc_traits<_Alloc> _Tp_alloc_type;
+  typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer pointer;
+  struct {
+    pointer _M_finish;
+  } _M_impl;
+};
+template <typename _Tp, typename _Alloc = allocator<_Tp>>
+class vector : _Vector_base<_Tp, _Alloc> {
+  typedef _Vector_base<_Tp, _Alloc> _Base;
+  typedef typename _Base::_Tp_alloc_type _Alloc_traits;
+
+public:
+  typedef _Tp value_type;
+  typedef typename _Base::pointer pointer;
+  typedef typename _Alloc_traits::const_pointer const_pointer;
+  typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
+  typedef __gnu_cxx::__normal_iterator<const_pointer, vector> const_iterator;
+  iterator begin();
+  iterator insert(const_iterator, const value_type &);
+  struct _Temporary_value {};
+  template <typename _Arg> void _M_insert_aux(iterator, _Arg &&);
+};
+template <typename _Tp, typename _Alloc>
+typename vector<_Tp, _Alloc>::iterator
+vector<_Tp, _Alloc>::insert(const_iterator, const value_type &) {
+  auto __pos = begin();
+  _Temporary_value __x_copy;
+  _M_insert_aux(__pos, __x_copy);
+}
+template <typename _Tp, typename _Alloc>
+template <typename _Arg>
+void vector<_Tp, _Alloc>::_M_insert_aux(iterator __position, _Arg &&) {
+  move_backward(__position.base(), this->_M_impl._M_finish,
+                this->_M_impl._M_finish);
+}
+namespace internals {
+struct distributing {
+  distributing &operator=(const distributing &);
+  int global_row;
+  *constraints; /* { dg-warning "with no type" "" } */
+};
+distributing &distributing::operator=(const distributing &in) {
+  global_row = in.global_row;
+  return; /* { dg-warning "return-statement with no value" "" } */
+}
+insert_index(vector<distributing> my_indices) { /* { dg-warning "with no type" "" } */
+  typedef vector<distributing>::iterator index_iterator;
+  index_iterator pos;
+  distributing row_value;
+  my_indices.insert(pos, row_value);
+}
+} // namespace internals
+} // namespace std

diff --git a/gcc/testsuite/gcc.target/riscv/rvv/rvv.exp b/gcc/testsuite/gcc.target/riscv/rvv/rvv.exp
index 877cc55bb88ea0444dd1721e26a5dab066fef9d5..e128b1733e8aec692ea7a44db8cafcd9696d50ab 100644 (file)
--- a/gcc/testsuite/gcc.target/riscv/rvv/rvv.exp
+++ b/gcc/testsuite/gcc.target/riscv/rvv/rvv.exp
@@ -47,7 +47,7 @@ dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/xandesvector/*.\[cS\]]] \
        "" $CFLAGS
 gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/vsetvl/*.\[cS\]]] \
        "" $CFLAGS
-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/autovec/*.\[cS\]]] \
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/autovec/*.\[cCS\]]] \
        "-O3 -ftree-vectorize" $CFLAGS
 dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/autovec/vls/*.\[cS\]]] \
        "-O3 -ftree-vectorize -mrvv-vector-bits=scalable" $CFLAGS

diff --git a/gcc/tree-vect-loop.cc b/gcc/tree-vect-loop.cc
index 53923c07e181cc330b8c4ac383cb02b3647d3963..f9dd88ed82468923ce6f1d01324a247a47169cde 100644 (file)
--- a/gcc/tree-vect-loop.cc
+++ b/gcc/tree-vect-loop.cc
@@ -2682,6 +2682,7 @@ again:
     = saved_can_use_partial_vectors_p;
   LOOP_VINFO_MUST_USE_PARTIAL_VECTORS_P (loop_vinfo) = false;
   LOOP_VINFO_USING_PARTIAL_VECTORS_P (loop_vinfo) = false;
+  LOOP_VINFO_USING_SELECT_VL_P (loop_vinfo) = false;
   if (loop_vinfo->scan_map)
     loop_vinfo->scan_map->empty ();