From: Jonathan Wakely <jwakely@redhat.com>
Date: Thu, 18 Oct 2018 21:41:01 +0000 (+0100)
Subject: PR libstdc++/87641 correctly initialize accumulator in valarray::sum()
X-Git-Tag: releases/gcc-6.5.0~12
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=4f9f5a0c05dbea06b650fed849798c44e52abd55;p=thirdparty%2Fgcc.git

PR libstdc++/87641 correctly initialize accumulator in valarray::sum()

Use the value of the first element as the initial value of the
__valarray_sum accumulator. Value-initialization might not create the
additive identity for the value type.

	PR libstdc++/87641
	* include/bits/valarray_array.h (__valarray_sum): Use first element
	to initialize accumulator instead of value-initializing it.
	* testsuite/26_numerics/valarray/87641.cc: New test.

From-SVN: r265291
---

diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index ef5e24772497..4024fc9e449f 100644
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,3 +1,13 @@
+2018-10-18  Jonathan Wakely  <jwakely@redhat.com>
+
+	Backport from mainline
+	2018-10-18  Jonathan Wakely  <jwakely@redhat.com>
+
+	PR libstdc++/87641
+	* include/bits/valarray_array.h (__valarray_sum): Use first element
+	to initialize accumulator instead of value-initializing it.
+	* testsuite/26_numerics/valarray/87641.cc: New test.
+
 2018-10-15  Jonathan Wakely  <jwakely@redhat.com>
 
 	* testsuite/22_locale/numpunct/members/char/3.cc: Adjust test to
diff --git a/libstdc++-v3/include/bits/valarray_array.h b/libstdc++-v3/include/bits/valarray_array.h
index 4df1181600e9..1f8f1b7d8b09 100644
--- a/libstdc++-v3/include/bits/valarray_array.h
+++ b/libstdc++-v3/include/bits/valarray_array.h
@@ -341,17 +341,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     }
 
   //
-  // Compute the sum of elements in range [__f, __l)
+  // Compute the sum of elements in range [__f, __l) which must not be empty.
   // This is a naive algorithm.  It suffers from cancelling.
-  // In the future try to specialize
-  // for _Tp = float, double, long double using a more accurate
-  // algorithm.
+  // In the future try to specialize for _Tp = float, double, long double
+  // using a more accurate algorithm.
   //
   template<typename _Tp>
     inline _Tp
     __valarray_sum(const _Tp* __f, const _Tp* __l)
     {
-      _Tp __r = _Tp();
+      _Tp __r = *__f++;
       while (__f != __l)
 	__r += *__f++;
       return __r;
diff --git a/libstdc++-v3/testsuite/26_numerics/valarray/87641.cc b/libstdc++-v3/testsuite/26_numerics/valarray/87641.cc
new file mode 100644
index 000000000000..eae5440e60b4
--- /dev/null
+++ b/libstdc++-v3/testsuite/26_numerics/valarray/87641.cc
@@ -0,0 +1,75 @@
+// Copyright (C) 2018 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/>.
+
+#include <valarray>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+  // PR libstdc++/87641
+  std::valarray<int> v1(3);
+  v1[0] = 1;
+  v1[1] = 2;
+  v1[2] = 3;
+  std::valarray< std::valarray<int> > v2(v1, 3);
+  std::valarray<int> v3 = v2.sum();
+  VERIFY( v3.size() == v1.size() );
+  VERIFY( v3[0] == 3 );
+  VERIFY( v3[1] == 6 );
+  VERIFY( v3[2] == 9 );
+}
+
+struct X
+{
+  X() : val(1) { }
+
+  X& operator+=(const X& x) { val += x.val; return *this; }
+  bool operator==(const X& x) { return val == x.val; }
+
+  int val;
+};
+
+void
+test02()
+{
+  std::valarray<X> v1(1);
+  VERIFY( v1.sum() == v1[0] );
+
+  std::valarray<X> v2(2);
+  VERIFY( v2.sum().val == 2 );
+}
+
+struct Y
+{
+  X& operator+=(const Y&) { throw 1; }
+};
+
+void
+test03()
+{
+  std::valarray<Y> v1(1);
+  (void) v1.sum(); // no addition performed for a single element
+}
+
+int
+main()
+{
+  test01();
+  test02();
+  test03();
+}