Skip to content

R
riscv-gcc-1
Commit a2f4bd2a by Ed Smith-Rowland Committed by Jonathan Wakely
Options

re PR libstdc++/61166 (overflow when parse number in std::duration operator"") 

2014-05-15  Ed Smith-Rowland  <3dw4rd@verizon.net>
	    Jonathan Wakely  <jwakely@redhat.com>

	PR libstdc++/61166
	* include/bits/parse_numbers.h: Use integral_constant to remove
	duplication and simplify.
	* testsuite/20_util/duration/literals/61166.cc: New.

Co-Authored-By: Jonathan Wakely <jwakely@redhat.com>

From-SVN: r210511
parent 88d4fbcf
Showing with 151 additions and 234 deletions
libstdc++-v3/ChangeLog
2014-05-15 Ed Smith-Rowland <3dw4rd@verizon.net>
Jonathan Wakely <jwakely@redhat.com>
PR libstdc++/61166
* include/bits/parse_numbers.h: Use integral_constant to remove
duplication and simplify.
* testsuite/20_util/duration/literals/61166.cc: New.
2014-05-15 Jonathan Wakely <jwakely@redhat.com> 2014-05-15 Jonathan Wakely <jwakely@redhat.com>
PR libstdc++/60326 PR libstdc++/60326
......
libstdc++-v3/include/bits/parse_numbers.h
...@@ -27,8 +27,8 @@ ...@@ -27,8 +27,8 @@
* Do not attempt to use it directly. @headername{chrono} * Do not attempt to use it directly. @headername{chrono}
*/ */
#ifndef _PARSE_NUMBERS_H #ifndef _GLIBCXX_PARSE_NUMBERS_H
#define _PARSE_NUMBERS_H 1 #define _GLIBCXX_PARSE_NUMBERS_H 1
#pragma GCC system_header #pragma GCC system_header
...@@ -36,289 +36,181 @@ ...@@ -36,289 +36,181 @@
#if __cplusplus > 201103L #if __cplusplus > 201103L
#include <limits>
namespace std _GLIBCXX_VISIBILITY(default) namespace std _GLIBCXX_VISIBILITY(default)
{ {
_GLIBCXX_BEGIN_NAMESPACE_VERSION _GLIBCXX_BEGIN_NAMESPACE_VERSION
namespace __parse_int { namespace __parse_int
{
template<unsigned _Base, char _Dig> template<unsigned _Base, char _Dig>
struct _Digit; struct _Digit;
template<unsigned _Base> template<unsigned _Base>
struct _Digit<_Base, '0'> struct _Digit<_Base, '0'> : integral_constant<unsigned, 0>
{ {
static constexpr bool valid{true}; using __valid = true_type;
static constexpr unsigned value{0};
}; };
template<unsigned _Base> template<unsigned _Base>
struct _Digit<_Base, '1'> struct _Digit<_Base, '1'> : integral_constant<unsigned, 1>
{ {
static constexpr bool valid{true}; using __valid = true_type;
static constexpr unsigned value{1};
}; };
template<unsigned _Base> template<unsigned _Base, unsigned _Val>
struct _Digit<_Base, '2'> struct _Digit_impl : integral_constant<unsigned, _Val>
{ {
static_assert(_Base > 2, "invalid digit"); static_assert(_Base > _Val, "invalid digit");
static constexpr bool valid{true}; using __valid = true_type;
static constexpr unsigned value{2};
}; };
template<unsigned _Base> template<unsigned _Base>
struct _Digit<_Base, '3'> struct _Digit<_Base, '2'> : _Digit_impl<_Base, 2>
{ { };
static_assert(_Base > 3, "invalid digit");
static constexpr bool valid{true};
static constexpr unsigned value{3};
};
template<unsigned _Base> template<unsigned _Base>
struct _Digit<_Base, '4'> struct _Digit<_Base, '3'> : _Digit_impl<_Base, 3>
{ { };
static_assert(_Base > 4, "invalid digit");
static constexpr bool valid{true};
static constexpr unsigned value{4};
};
template<unsigned _Base> template<unsigned _Base>
struct _Digit<_Base, '5'> struct _Digit<_Base, '4'> : _Digit_impl<_Base, 4>
{ { };
static_assert(_Base > 5, "invalid digit");
static constexpr bool valid{true};
static constexpr unsigned value{5};
};
template<unsigned _Base> template<unsigned _Base>
struct _Digit<_Base, '6'> struct _Digit<_Base, '5'> : _Digit_impl<_Base, 5>
{ { };
static_assert(_Base > 6, "invalid digit");
static constexpr bool valid{true};
static constexpr unsigned value{6};
};
template<unsigned _Base> template<unsigned _Base>
struct _Digit<_Base, '7'> struct _Digit<_Base, '6'> : _Digit_impl<_Base, 6>
{ { };
static_assert(_Base > 7, "invalid digit");
static constexpr bool valid{true};
static constexpr unsigned value{7};
};
template<unsigned _Base> template<unsigned _Base>
struct _Digit<_Base, '8'> struct _Digit<_Base, '7'> : _Digit_impl<_Base, 7>
{ { };
static_assert(_Base > 8, "invalid digit");
static constexpr bool valid{true};
static constexpr unsigned value{8};
};
template<unsigned _Base> template<unsigned _Base>
struct _Digit<_Base, '9'> struct _Digit<_Base, '8'> : _Digit_impl<_Base, 8>
{ { };
static_assert(_Base > 9, "invalid digit");
static constexpr bool valid{true};
static constexpr unsigned value{9};
};
template<unsigned _Base> template<unsigned _Base>
struct _Digit<_Base, 'a'> struct _Digit<_Base, '9'> : _Digit_impl<_Base, 9>
{ { };
static_assert(_Base > 0xa, "invalid digit");
static constexpr bool valid{true};
static constexpr unsigned value{0xa};
};
template<unsigned _Base> template<unsigned _Base>
struct _Digit<_Base, 'A'> struct _Digit<_Base, 'a'> : _Digit_impl<_Base, 0xa>
{ { };
static_assert(_Base > 0xa, "invalid digit");
static constexpr bool valid{true};
static constexpr unsigned value{0xa};
};
template<unsigned _Base> template<unsigned _Base>
struct _Digit<_Base, 'b'> struct _Digit<_Base, 'A'> : _Digit_impl<_Base, 0xa>
{ { };
static_assert(_Base > 0xb, "invalid digit");
static constexpr bool valid{true};
static constexpr unsigned value{0xb};
};
template<unsigned _Base> template<unsigned _Base>
struct _Digit<_Base, 'B'> struct _Digit<_Base, 'b'> : _Digit_impl<_Base, 0xb>
{ { };
static_assert(_Base > 0xb, "invalid digit");
static constexpr bool valid{true};
static constexpr unsigned value{0xb};
};
template<unsigned _Base> template<unsigned _Base>
struct _Digit<_Base, 'c'> struct _Digit<_Base, 'B'> : _Digit_impl<_Base, 0xb>
{ { };
static_assert(_Base > 0xc, "invalid digit");
static constexpr bool valid{true};
static constexpr unsigned value{0xc};
};
template<unsigned _Base> template<unsigned _Base>
struct _Digit<_Base, 'C'> struct _Digit<_Base, 'c'> : _Digit_impl<_Base, 0xc>
{ { };
static_assert(_Base > 0xc, "invalid digit");
static constexpr bool valid{true};
static constexpr unsigned value{0xc};
};
template<unsigned _Base> template<unsigned _Base>
struct _Digit<_Base, 'd'> struct _Digit<_Base, 'C'> : _Digit_impl<_Base, 0xc>
{ { };
static_assert(_Base > 0xd, "invalid digit");
static constexpr bool valid{true};
static constexpr unsigned value{0xd};
};
template<unsigned _Base> template<unsigned _Base>
struct _Digit<_Base, 'D'> struct _Digit<_Base, 'd'> : _Digit_impl<_Base, 0xd>
{ { };
static_assert(_Base > 0xd, "invalid digit");
static constexpr bool valid{true};
static constexpr unsigned value{0xd};
};
template<unsigned _Base> template<unsigned _Base>
struct _Digit<_Base, 'e'> struct _Digit<_Base, 'D'> : _Digit_impl<_Base, 0xd>
{ { };
static_assert(_Base > 0xe, "invalid digit");
static constexpr bool valid{true};
static constexpr unsigned value{0xe};
};
template<unsigned _Base> template<unsigned _Base>
struct _Digit<_Base, 'E'> struct _Digit<_Base, 'e'> : _Digit_impl<_Base, 0xe>
{ { };
static_assert(_Base > 0xe, "invalid digit");
static constexpr bool valid{true};
static constexpr unsigned value{0xe};
};
template<unsigned _Base> template<unsigned _Base>
struct _Digit<_Base, 'f'> struct _Digit<_Base, 'E'> : _Digit_impl<_Base, 0xe>
{ { };
static_assert(_Base > 0xf, "invalid digit");
static constexpr bool valid{true};
static constexpr unsigned value{0xf};
};
template<unsigned _Base> template<unsigned _Base>
struct _Digit<_Base, 'F'> struct _Digit<_Base, 'f'> : _Digit_impl<_Base, 0xf>
{ { };
static_assert(_Base > 0xf, "invalid digit");
static constexpr bool valid{true};
static constexpr unsigned value{0xf};
};
// Digit separator
template<unsigned _Base> template<unsigned _Base>
struct _Digit<_Base, '\''> struct _Digit<_Base, 'F'> : _Digit_impl<_Base, 0xf>
{ { };
static constexpr bool valid{false};
static constexpr unsigned value{0};
};
//------------------------------------------------------------------------------
template<unsigned _Base, char _Dig, char... _Digs>
struct _Digits_help
{
static constexpr unsigned
value{_Digit<_Base, _Dig>::valid ?
1U + _Digits_help<_Base, _Digs...>::value :
_Digits_help<_Base, _Digs...>::value};
};
template<unsigned _Base, char _Dig>
struct _Digits_help<_Base, _Dig>
{
static constexpr unsigned value{_Digit<_Base, _Dig>::valid ? 1U : 0U};
};
template<unsigned _Base, char... _Digs>
struct _Digits
{
static constexpr unsigned value{_Digits_help<_Base, _Digs...>::value};
};
// Digit separator
template<unsigned _Base> template<unsigned _Base>
struct _Digits<_Base> struct _Digit<_Base, '\''> : integral_constant<unsigned, 0>
{ {
static constexpr unsigned value{0U}; using __valid = false_type;
}; };
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
template<unsigned long long _Val>
using __ull_constant = integral_constant<unsigned long long, _Val>;
template<unsigned _Base, char _Dig, char... _Digs> template<unsigned _Base, char _Dig, char... _Digs>
struct _Power_help struct _Power_help
{ {
static constexpr unsigned using __next = typename _Power_help<_Base, _Digs...>::type;
value{_Digit<_Base, _Dig>::valid ? using __valid_digit = typename _Digit<_Base, _Dig>::__valid;
_Base * _Power_help<_Base, _Digs...>::value : using type
_Power_help<_Base, _Digs...>::value}; = __ull_constant<__next::value * (__valid_digit{} ? _Base : 1ULL)>;
}; };
template<unsigned _Base, char _Dig> template<unsigned _Base, char _Dig>
struct _Power_help<_Base, _Dig> struct _Power_help<_Base, _Dig>
{ {
static constexpr unsigned value{_Digit<_Base, _Dig>::valid ? 1U : 0U}; using __valid_digit = typename _Digit<_Base, _Dig>::__valid;
using type = __ull_constant<__valid_digit::value>;
}; };
template<unsigned _Base, char... _Digs> template<unsigned _Base, char... _Digs>
struct _Power struct _Power : _Power_help<_Base, _Digs...>::type
{ { };
static constexpr unsigned value{_Power_help<_Base, _Digs...>::value};
};
template<unsigned _Base> template<unsigned _Base>
struct _Power<_Base> struct _Power<_Base> : __ull_constant<0>
{ { };
static constexpr unsigned value{0U};
};
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
template<unsigned _Base, unsigned _Pow, char _Dig, char... _Digs> template<unsigned _Base, unsigned long long _Pow, char _Dig, char... _Digs>
struct _Number_help struct _Number_help
{ {
static constexpr unsigned using __digit = _Digit<_Base, _Dig>;
value{_Digit<_Base, _Dig>::valid ? using __valid_digit = typename __digit::__valid;
_Pow * _Digit<_Base, _Dig>::value using __next = _Number_help<_Base,
+ _Number_help<_Base, _Pow / _Base, _Digs...>::value : _Pow / (_Base * __valid_digit::value),
_Number_help<_Base, _Pow, _Digs...>::value}; _Digs...>;
using type = __ull_constant<_Pow * __digit::value + __next::type::value>;
}; };
template<unsigned _Base, unsigned _Pow, char _Dig> template<unsigned _Base, unsigned long long _Pow, char _Dig>
struct _Number_help<_Base, _Pow, _Dig> struct _Number_help<_Base, _Pow, _Dig>
{ {
//static_assert(_Pow == 1U, "power should be one"); //static_assert(_Pow == 1U, "power should be one");
static constexpr unsigned using type = __ull_constant<_Digit<_Base, _Dig>::value>;
value{_Digit<_Base, _Dig>::valid ? _Digit<_Base, _Dig>::value : 0U};
}; };
template<unsigned _Base, char... _Digs> template<unsigned _Base, char... _Digs>
struct _Number struct _Number
{ : _Number_help<_Base, _Power<_Base, _Digs...>::value, _Digs...>::type
static constexpr unsigned { };
value{_Number_help<_Base, _Power<_Base, _Digs...>::value,
_Digs...>::value};
};
template<unsigned _Base> template<unsigned _Base>
struct _Number<_Base> struct _Number<_Base>
{ : __ull_constant<0>
static constexpr unsigned value{0U}; { };
};
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// This _Parse_int is the same 'level' as the old _Base_dispatch. // This _Parse_int is the same 'level' as the old _Base_dispatch.
...@@ -328,84 +220,62 @@ namespace __parse_int { ...@@ -328,84 +220,62 @@ namespace __parse_int {
template<char... _Digs> template<char... _Digs>
struct _Parse_int<'0', 'b', _Digs...> struct _Parse_int<'0', 'b', _Digs...>
{ : _Number<2U, _Digs...>::type
static constexpr unsigned long long { };
value{_Number<2U, _Digs...>::value};
};
template<char... _Digs> template<char... _Digs>
struct _Parse_int<'0', 'B', _Digs...> struct _Parse_int<'0', 'B', _Digs...>
{ : _Number<2U, _Digs...>::type
static constexpr unsigned long long { };
value{_Number<2U, _Digs...>::value};
};
template<char... _Digs> template<char... _Digs>
struct _Parse_int<'0', 'x', _Digs...> struct _Parse_int<'0', 'x', _Digs...>
{ : _Number<16U, _Digs...>::type
static constexpr unsigned long long { };
value{_Number<16U, _Digs...>::value};
};
template<char... _Digs> template<char... _Digs>
struct _Parse_int<'0', 'X', _Digs...> struct _Parse_int<'0', 'X', _Digs...>
{ : _Number<16U, _Digs...>::type
static constexpr unsigned long long { };
value{_Number<16U, _Digs...>::value};
};
template<char... _Digs> template<char... _Digs>
struct _Parse_int<'0', _Digs...> struct _Parse_int<'0', _Digs...>
{ : _Number<8U, _Digs...>::type
static constexpr unsigned long long { };
value{_Number<8U, _Digs...>::value};
};
template<char... _Digs> template<char... _Digs>
struct _Parse_int struct _Parse_int
{ : _Number<10U, _Digs...>::type
static constexpr unsigned long long { };
value{_Number<10U, _Digs...>::value};
};
} // namespace __parse_int } // namespace __parse_int
namespace __select_int { namespace __select_int
{
template<unsigned long long _Val, typename... _Ints> template<unsigned long long _Val, typename... _Ints>
struct _Select_int_base; struct _Select_int_base;
template<unsigned long long _Val, typename _IntType, typename... _Ints> template<unsigned long long _Val, typename _IntType, typename... _Ints>
struct _Select_int_base<_Val, _IntType, _Ints...> struct _Select_int_base<_Val, _IntType, _Ints...>
: integral_constant : conditional_t<(_Val <= std::numeric_limits<_IntType>::max()),
< integral_constant<_IntType, _Val>,
typename conditional _Select_int_base<_Val, _Ints...>>
<
_Val <= static_cast<unsigned long long>
(std::numeric_limits<_IntType>::max()),
_IntType,
typename _Select_int_base<_Val, _Ints...>::value_type
>::type,
_Val
>
{ }; { };
template<unsigned long long _Val> template<unsigned long long _Val>
struct _Select_int_base<_Val> : integral_constant<unsigned long long, _Val> struct _Select_int_base<_Val>
{ }; { };
template<char... _Digs> template<char... _Digs>
struct _Select_int using _Select_int = typename _Select_int_base<
: _Select_int_base<
__parse_int::_Parse_int<_Digs...>::value, __parse_int::_Parse_int<_Digs...>::value,
unsigned char, unsigned char,
unsigned short, unsigned short,
unsigned int, unsigned int,
unsigned long, unsigned long,
unsigned long long unsigned long long
> >::type;
{ };
} // namespace __select_int } // namespace __select_int
...@@ -414,4 +284,4 @@ _GLIBCXX_END_NAMESPACE_VERSION ...@@ -414,4 +284,4 @@ _GLIBCXX_END_NAMESPACE_VERSION
#endif // __cplusplus > 201103L #endif // __cplusplus > 201103L
#endif // _PARSE_NUMBERS_H #endif // _GLIBCXX_PARSE_NUMBERS_H
libstdc++-v3/testsuite/20_util/duration/literals/61166.cc 0 → 100644
// { dg-do run }
// { dg-options "-std=gnu++1y" }
// Copyright (C) 2014 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/>.
// libstdc++/61166
#include <chrono>
#include <testsuite_hooks.h>
void
test01()
{
using namespace std::literals::chrono_literals;
// std::numeric_limits<unsigned>::max() == 4294967295
VERIFY( (429496729510h).count() == 429496729510 );
}
int
main()
{
test01();
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment