PR78346 make <bits/predefined_ops.h> handle stashing iterators

PR libstdc++/78346
	* include/bits/predefined_ops.h (_Iter_equals_iter): Store iterator
	not its referent.
	(_Iter_comp_to_iter): Likewise.
	* testsuite/25_algorithms/search/78346.cc: New test.

From-SVN: r245090

libstdc++-v3/ChangeLog

@@ -1,5 +1,11 @@
 2017-02-01  Jonathan Wakely  <jwakely@redhat.com>
 
+	PR libstdc++/78346
+	* include/bits/predefined_ops.h (_Iter_equals_iter): Store iterator
+	not its referent.
+	(_Iter_comp_to_iter): Likewise.
+	* testsuite/25_algorithms/search/78346.cc: New test.
+
 	PR libstdc++/79254
 	* config/abi/pre/gnu.ver: Remove recently added symbols.
 	* include/bits/basic_string.h [_GLIBCXX_USE_CXX11_ABI]

libstdc++-v3/include/bits/predefined_ops.h

@@ -24,7 +24,7 @@
 
 /** @file predefined_ops.h
  *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
+ *  You should not attempt to use it directly. @headername{algorithm}
  */
 
 #ifndef _GLIBCXX_PREDEFINED_OPS_H
@@ -249,17 +249,17 @@ namespace __ops
   template<typename _Iterator1>
     struct _Iter_equals_iter
     {
-      typename std::iterator_traits<_Iterator1>::reference _M_ref;
+      _Iterator1 _M_it1;
 
       explicit
       _Iter_equals_iter(_Iterator1 __it1)
-	: _M_ref(*__it1)
+	: _M_it1(__it1)
       { }
 
       template<typename _Iterator2>
 	bool
 	operator()(_Iterator2 __it2)
-	{ return *__it2 == _M_ref; }
+	{ return *__it2 == *_M_it1; }
     };
 
   template<typename _Iterator>
@@ -315,16 +315,16 @@ namespace __ops
     struct _Iter_comp_to_iter
     {
       _Compare _M_comp;
-      typename std::iterator_traits<_Iterator1>::reference _M_ref;
+      _Iterator1 _M_it1;
 
       _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
-	: _M_comp(_GLIBCXX_MOVE(__comp)), _M_ref(*__it1)
+	: _M_comp(_GLIBCXX_MOVE(__comp)), _M_it1(__it1)
       { }
 
       template<typename _Iterator2>
 	bool
 	operator()(_Iterator2 __it2)
-	{ return bool(_M_comp(*__it2, _M_ref)); }
+	{ return bool(_M_comp(*__it2, *_M_it1)); }
     };
 
   template<typename _Compare, typename _Iterator>

libstdc++-v3/testsuite/25_algorithms/search/78346.cc

@@ -0,0 +1,118 @@
+// Copyright (C) 2017 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-do run { target c++11 } }
+
+#include <algorithm>
+#include <testsuite_hooks.h>
+
+bool values[100];
+
+unsigned next_id()
+{
+  static unsigned counter = 0;
+  VERIFY(counter < 100);
+  return counter++;
+}
+
+struct value
+{
+  int val;
+  const unsigned id;
+
+  value(int i = 0) : val(i), id(next_id()) { values[id] = true; }
+  value(const value& v) : val(v.val), id(next_id()) { values[id] = true; }
+  value& operator=(const value& v) { val = v.val; return *this; }
+  ~value() { values[id] = false; }
+};
+
+bool operator<(const value& lhs, const value& rhs)
+{
+  if (!values[lhs.id])
+    throw lhs.id;
+  if (!values[rhs.id])
+    throw rhs.id;
+  return lhs.val < rhs.val;
+}
+
+bool operator==(const value& lhs, const value& rhs)
+{
+  if (!values[lhs.id])
+    throw lhs.id;
+  if (!values[rhs.id])
+    throw rhs.id;
+  return lhs.val == rhs.val;
+}
+
+// A forward iterator that fails to meet the requirement that for any
+// two dereferenceable forward iterators, a == b implies &*a == &*b
+struct stashing_iterator
+{
+  typedef std::forward_iterator_tag iterator_category;
+  typedef value value_type;
+  typedef value_type const* pointer;
+  typedef value_type const& reference;
+  typedef std::ptrdiff_t difference_type;
+
+  stashing_iterator() : ptr(), stashed() { }
+  stashing_iterator(pointer p) : ptr(p), stashed() { stash(); }
+  stashing_iterator(const stashing_iterator&) = default;
+  stashing_iterator& operator=(const stashing_iterator&) = default;
+
+  stashing_iterator& operator++()
+  {
+    ++ptr;
+    stash();
+    return *this;
+  }
+
+  stashing_iterator operator++(int)
+  {
+    stashing_iterator i = *this;
+    ++*this;
+    return i;
+  }
+
+  reference operator*() const { return stashed; }
+  pointer operator->() const { return &**this; }
+
+  bool operator==(const stashing_iterator& i) const { return ptr == i.ptr; }
+  bool operator!=(const stashing_iterator& i) const { return !(*this == i); }
+
+private:
+  void stash()
+  {
+    if (ptr)
+      stashed = *ptr;
+  }
+
+  pointer ptr;
+  value_type stashed;
+};
+
+void
+test01()
+{
+  value s[] = { 0, 1, 2, 3, 4, 5 };
+  std::search(s, s+6, stashing_iterator(s), stashing_iterator(s+4));
+}
+
+int
+main()
+{
+  test01();
+}