From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 52742 invoked by alias); 18 Oct 2018 15:38:01 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 52715 invoked by uid 89); 18 Oct 2018 15:38:01 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-26.9 required=5.0 tests=BAYES_00,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,SPF_HELO_PASS,TIME_LIMIT_EXCEEDED autolearn=unavailable version=3.3.2 spammy=Map, 26_numerics, non-empty, nonempty X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Thu, 18 Oct 2018 15:37:51 +0000 Received: from smtp.corp.redhat.com (int-mx07.intmail.prod.int.phx2.redhat.com [10.5.11.22]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id E719F80F6C; Thu, 18 Oct 2018 15:37:49 +0000 (UTC) Received: from localhost (unknown [10.33.36.104]) by smtp.corp.redhat.com (Postfix) with ESMTP id 8FD511057056; Thu, 18 Oct 2018 15:37:49 +0000 (UTC) Date: Thu, 18 Oct 2018 16:13:00 -0000 From: Jonathan Wakely To: libstdc++@gcc.gnu.org, gcc-patches@gcc.gnu.org Subject: [PATCH] PR libstdc++/87641 correctly initialize accumulator in valarray::sum() Message-ID: <20181018153748.GA3505@redhat.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="FCuugMFkClbJLl1L" Content-Disposition: inline X-Clacks-Overhead: GNU Terry Pratchett User-Agent: Mutt/1.9.2 (2017-12-15) X-SW-Source: 2018-10/txt/msg01117.txt.bz2 --FCuugMFkClbJLl1L Content-Type: text/plain; charset=us-ascii; format=flowed Content-Disposition: inline Content-length: 894 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. Make a similar change to __valarray_product even though it's only ever used internally with a value_type of size_t. PR libstdc++/87641 * include/bits/valarray_array.h (__valarray_sum): Use first element to initialize accumulator instead of value-initializing it. (__valarray_product<_Tp>): Move to ... * src/c++98/valarray.cc (__valarray_product<_Tp>): Here. Use first element to initialize accumulator. (__valarray_product(const valarray&)): Remove const_cast made unnecessary by LWG 389. * testsuite/26_numerics/valarray/87641.cc: New test. Tested powerpc64le-linux, committed to trunk. This seems perfectly safe so I'll backport this to the branches too, without the changes to __valarray_product. --FCuugMFkClbJLl1L Content-Type: text/plain; charset=us-ascii Content-Disposition: attachment; filename="patch.txt" Content-length: 5565 commit 7b9d4da1fcf6ea3edc85ee960da1c1135614622c Author: Jonathan Wakely Date: Thu Oct 18 12:32:39 2018 +0100 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. Make a similar change to __valarray_product even though it's only ever used internally with a value_type of size_t. PR libstdc++/87641 * include/bits/valarray_array.h (__valarray_sum): Use first element to initialize accumulator instead of value-initializing it. (__valarray_product<_Tp>): Move to ... * src/c++98/valarray.cc (__valarray_product<_Tp>): Here. Use first element to initialize accumulator. (__valarray_product(const valarray&)): Remove const_cast made unnecessary by LWG 389. * testsuite/26_numerics/valarray/87641.cc: New test. diff --git a/libstdc++-v3/include/bits/valarray_array.h b/libstdc++-v3/include/bits/valarray_array.h index 6759d6003e9..2dd1ec836ac 100644 --- a/libstdc++-v3/include/bits/valarray_array.h +++ b/libstdc++-v3/include/bits/valarray_array.h @@ -338,33 +338,21 @@ _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 inline _Tp __valarray_sum(const _Tp* __f, const _Tp* __l) { - _Tp __r = _Tp(); + _Tp __r = *__f++; while (__f != __l) __r += *__f++; return __r; } - // Compute the product of all elements in range [__f, __l) - template - inline _Tp - __valarray_product(const _Tp* __f, const _Tp* __l) - { - _Tp __r = _Tp(1); - while (__f != __l) - __r = __r * *__f++; - return __r; - } - // Compute the min/max of an array-expression template inline typename _Ta::value_type diff --git a/libstdc++-v3/src/c++98/valarray.cc b/libstdc++-v3/src/c++98/valarray.cc index 3cec1843be2..284db21e81c 100644 --- a/libstdc++-v3/src/c++98/valarray.cc +++ b/libstdc++-v3/src/c++98/valarray.cc @@ -45,15 +45,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template size_t valarray::size() const; template size_t& valarray::operator[](size_t); + // Compute the product of all elements in the non-empty range [__f, __l) + template + inline _Tp + __valarray_product(const _Tp* __f, const _Tp* __l) + { + _Tp __r = *__f++; + while (__f != __l) + __r = __r * *__f++; + return __r; + } + inline size_t __valarray_product(const valarray& __a) { - const size_t __n = __a.size(); - // XXX: This ugly cast is necessary because - // valarray::operator[]() const return a VALUE! - // Try to get the committee to correct that gross error. - valarray& __t = const_cast&>(__a); - return __valarray_product(&__t[0], &__t[0] + __n); + return __valarray_product(&__a[0], &__a[0] + __a.size()); } // Map a gslice, described by its multidimensional LENGTHS 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 00000000000..eae5440e60b --- /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 +// . + +#include +#include + +void +test01() +{ + // PR libstdc++/87641 + std::valarray v1(3); + v1[0] = 1; + v1[1] = 2; + v1[2] = 3; + std::valarray< std::valarray > v2(v1, 3); + std::valarray 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 v1(1); + VERIFY( v1.sum() == v1[0] ); + + std::valarray v2(2); + VERIFY( v2.sum().val == 2 ); +} + +struct Y +{ + X& operator+=(const Y&) { throw 1; } +}; + +void +test03() +{ + std::valarray v1(1); + (void) v1.sum(); // no addition performed for a single element +} + +int +main() +{ + test01(); + test02(); + test03(); +} --FCuugMFkClbJLl1L--