aboutsummaryrefslogtreecommitdiff
path: root/libstdc++-v3/config
AgeCommit message (Collapse)AuthorFilesLines
2021-12-02libstdc++: Remove broken std::allocator base classes [PR103340]Jonathan Wakely3-165/+0
The bitmap_allocator, __mt_alloc and __pool_alloc extensions are no longer suitable for use as the base class of std::allocator, because they have not been updated to meet the C++20 requirements. There is a patch attached to PR 103340 which addresses that, but more work would be needed to solve the linking errors that occur when the library is configured to use them. Using --enable-libstdcxx-allocator=bitmap wouldn't even bootstrap for the past few years, and I can't find any gcc-testresults reports using any of these allocators. This patch removes the configure option to use these as the std::allocator base class. The allocators are still in the tree and can be used directly, you just can't configure the library to use one of them as the base class of std::allocator. libstdc++-v3/ChangeLog: PR libstdc++/103340 PR libstdc++/103400 PR libstdc++/103381 * acinclude.m4 (GLIBCXX_ENABLE_ALLOCATOR): Remove mt, bitmap and pool options. * configure: Regenerate. * config/allocator/bitmap_allocator_base.h: Removed. * config/allocator/mt_allocator_base.h: Removed. * config/allocator/pool_allocator_base.h: Removed. * doc/xml/manual/allocator.xml: Update. * doc/xml/manual/configure.xml: Update. * doc/xml/manual/evolution.xml: Document removal. * doc/xml/manual/mt_allocator.xml: Editorial tweaks. * doc/html/manual/*: Regenerate.
2021-11-30libstdc++: Make Asan detection work for Clang [PR103453]Jonathan Wakely2-4/+16
Clang doesn't define __SANITIZE_ADDRESS__ so use its __has_feature check to detect Asan instead. libstdc++-v3/ChangeLog: PR libstdc++/103453 * config/allocator/malloc_allocator_base.h (_GLIBCXX_SANITIZE_STD_ALLOCATOR): Define for Clang. * config/allocator/new_allocator_base.h (_GLIBCXX_SANITIZE_STD_ALLOCATOR): Likewise.
2021-11-19libstdc++: Fix ctype changed after newlib update.Tamar Christina1-1/+18
Newlib changed ctype.h recently[1] by moving the short labels from ctype.h intro the private namespace in ctype_.h. This broke embedded builds due to them no longer being found. Instead they now expose the long names to match glibc. This patch now uses the short or long names depending on is the short ones are defined or not. [1] https://github.com/bminor/newlib/commit/3ba1bd0d9dbc015c14a0aaafcef042f706d1249a libstdc++-v3/ChangeLog: PR libstdc++/103305 * config/os/newlib/ctype_base.h (upper, lower, alpha, digit, xdigit, space, print, graph, cntrl, punct, alnum, blank): Use short or long names depending on if short ones are defined.
2021-11-12libstdc++: Print assertion messages to stderr [PR59675]Jonathan Wakely1-0/+6
This replaces the printf used by failed debug assertions with fprintf, so we can write to stderr. To avoid including <stdio.h> the assert function is moved into the library. To avoid programs using a vague linkage definition of the old inline function, the function is renamed. Code compiled with old versions of GCC might still call the old function, but code compiled with the newer GCC will call the new function and write to stderr. libstdc++-v3/ChangeLog: PR libstdc++/59675 * acinclude.m4 (libtool_VERSION): Bump version. * config/abi/pre/gnu.ver (GLIBCXX_3.4.30): Add version and export new symbol. * configure: Regenerate. * include/bits/c++config (__replacement_assert): Remove, declare __glibcxx_assert_fail instead. * src/c++11/debug.cc (__glibcxx_assert_fail): New function to replace __replacement_assert, writing to stderr instead of stdout. * testsuite/util/testsuite_abi.cc: Update latest version.
2021-11-10libstdc++: Disable gthreads weak symbols for glibc 2.34 [PR103133]Jonathan Wakely1-0/+6
Since Glibc 2.34 all pthreads symbols are defined directly in libc not libpthread, and since Glibc 2.32 we have used __libc_single_threaded to avoid unnecessary locking in single-threaded programs. This means there is no reason to avoid linking to libpthread now, and so no reason to use weak symbols defined in gthr-posix.h for all the pthread_xxx functions. libstdc++-v3/ChangeLog: PR libstdc++/100748 PR libstdc++/103133 * config/os/gnu-linux/os_defines.h (_GLIBCXX_GTHREAD_USE_WEAK): Define for glibc 2.34 and later.
2021-11-09libstdc++: only define _GLIBCXX_HAVE_TLS for VxWorks >= 6.6Rasmus Villemoes1-1/+3
According to https://gcc.gnu.org/legacy-ml/gcc-patches/2008-03/msg01698.html, the TLS support, including the __tls_lookup function, was added to VxWorks in 6.6. It certainly doesn't exist on our VxWorks 5 platform, but the fallback code in eh_globals.cc using __gthread_key_create() etc. used to work just fine. libstdc++-v3/ChangeLog: * config/os/vxworks/os_defines.h (_GLIBCXX_HAVE_TLS): Only define for VxWorks >= 6.6.
2021-07-22aix: Protect AIX math.h overloads with new macro.David Edelsohn1-0/+5
AIX math.h provides C++ overloaded inlined math functions, which should not be present for G++. The definitions have been guaded by __COMPATMATH__, but that macro had other uses in IBM xlC++. A new macro has been introduced with the sole purpose of guarding the functions. This patch updates libstdc++ os_defines.h to define the additional macro. The earlier macro definition is retained to guard the functions in the math.h header of earlier AIX releases. libstdc++-v3/ChangeLog: * config/os/aix/os_defines.h (__LIBC_NO_CPP_MATH_OVERLOADS__): Define.
2021-05-04ctype support for libstdc++ on VxWorksCorentin Gay4-1/+367
for libstdc++-v3/ChangeLog * acinclude.m4: Add VxWorks-specific case for the configuration of ctypes. * configure: Regenerate. * config/locale/vxworks/ctype_members.cc: Add VxWorks-specific version. * config/os/vxworks/ctype_base.h: Adjust for VxWorks7+. * config/os/vxworks/ctype_configure_char.cc: Likewise. * config/os/vxworks/ctype_inline.h: Likewise. * testsuite/28_regex/traits/char/isctype.cc: Defines NEWLINE_IN_CLASS_BLANK if the target is VxWorks. * testsuite/28_regex/traits/wchar_t/isctype.cc: Likewise.
2021-04-22aix: delete AIX pre-PowerPC version of atomicity.hDavid Edelsohn1-56/+0
The AIX-specific version of atomicity.h that provides compatibility for the origina POWER architecture without atomic instructions no longer is referenced. This patch deletes the file. libstdc++-v3/ChangeLog: * config/os/aix/atomicity.h: Delete.
2021-04-22libstdc++: Fix typo in commentJonathan Wakely1-1/+1
libstdc++-v3/ChangeLog: * config/os/gnu-linux/os_defines.h: Fix type in comment.
2021-04-20libstdc++: Update ppc64le baseline_symbols.txtJakub Jelinek1-0/+242
> Tested on powerpc64{,le}-linux now (-m32/-m64 on be) and while the first > patch works fine, the second one unfortunately doesn't on either be or le, > so more work is needed there. Here are the needed changes to make it work. For symbols with _LDBL_ substring in version name we already have code to ignore those if no such symbols appear (but it is slightly incorrect, see below). So, this patch does the same thing for symbol versions with _IEEE128_ substring. The previously incorrectly handled case is that in addition to FUNC:_ZNKSt17__gnu_cxx_ieee1287num_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE14_M_extract_intImEES4_S4_S4_RSt8ios_baseRSt12_Ios_IostateRT_@@GLIBCXX_IEEE128_3.4.29 or OBJECT:12:_ZTSu9__ieee128@@CXXABI_IEEE128_1.3.13 cases we also have the OBJECT:0:CXXABI_IEEE128_1.3.13 OBJECT:0:GLIBCXX_IEEE128_3.4.29 cases, which have empty version_name and the name is in that case the symbol version. Those need to be ignored too. 2021-04-20 Jakub Jelinek <jakub@redhat.com> * testsuite/util/testsuite_abi.cc (compare_symbols): If any symbol versions with _IEEE128_ substring are found, set ieee_version_found to true. Ignore missing symbols with _IEEE128_ in version name if !ieee_version_found. Use i->first as version_name instead of i->second.version_name if the latter is empty. * config/abi/post/powerpc64-linux-gnu/baseline_symbols.txt: Update.
2021-04-19libstdc++: Update some baseline_symbols.txt (x32)H.J. Lu1-0/+102
* config/abi/post/x86_64-linux-gnu/x32/baseline_symbols.txt: Updated.
2021-04-17libstdc++: Update ppc32 baseline_symbols.txtJakub Jelinek2-0/+214
And here is an update for 32-bit powerpc-linux. 2021-04-17 Jakub Jelinek <jakub@redhat.com> * config/abi/post/powerpc-linux-gnu/baseline_symbols.txt: Update. * config/abi/post/powerpc64-linux-gnu/32/baseline_symbols.txt: Update.
2021-04-17libstdc++: Update some baseline_symbols.txtJakub Jelinek6-0/+622
As we have only one P1 left right now, I think it is the right time to update abi list files in libstdc++. Here is an update for x86_64/i?86/s390x/ppc64 linux (aarch64 seems to be correct already). For ppc64le it is missing the IEEE128 symver symbols, but those need further work on the abi checking side. 2021-04-17 Jakub Jelinek <jakub@redhat.com> * config/abi/post/x86_64-linux-gnu/baseline_symbols.txt: Update. * config/abi/post/x86_64-linux-gnu/32/baseline_symbols.txt: Update. * config/abi/post/i386-linux-gnu/baseline_symbols.txt: Update. * config/abi/post/i486-linux-gnu/baseline_symbols.txt: Update. * config/abi/post/s390x-linux-gnu/baseline_symbols.txt: Update. * config/abi/post/powerpc64-linux-gnu/baseline_symbols.txt: Update.
2021-03-16libstdc++: Remove symbols for new std::call_once implementation [PR 99341]Jonathan Wakely5-13/+0
This removes the new symbols added for the new futex-based std::call_once implementation. These symbols were new on trunk, so not in any released version. However, they are already present in some beta distro releases (Fedora Linux 34) and in Fedora Linux rawhide. This change can be locally reverted by distros that need to keep the symbols present until affected packages have been rebuilt. libstdc++-v3/ChangeLog: PR libstdc++/99341 * config/abi/post/aarch64-linux-gnu/baseline_symbols.txt: Remove std::once_flag symbols. * config/abi/post/ia64-linux-gnu/baseline_symbols.txt: Likewise. * config/abi/post/m68k-linux-gnu/baseline_symbols.txt: Likewise. * config/abi/post/riscv64-linux-gnu/baseline_symbols.txt: Likewise. * config/abi/pre/gnu.ver: Likewise. * src/c++11/mutex.cc [_GLIBCXX_HAVE_LINUX_FUTEX] (struct __once_flag_compat): Remove. (_ZNSt9once_flag11_M_activateEv): Remove. (_ZNSt9once_flag9_M_finishEb): Remove.
2021-03-15libstdc++, Darwin, ppc : Add new long double symbols.Iain Sandoe1-0/+3
We need to add the symbols for to_chars and from_chars for the long double cases. libstdc++-v3/ChangeLog: * config/os/bsd/darwin/ppc-extra.ver: Add matching for to_chars and from_chars for long double.
2021-03-03libstdc++: Update Solaris baselines for GCC 11.1Rainer Orth4-0/+392
The following patch updates the Solaris baselines for GCC 11.1. There's only one caveat: comparing the Solaris 11.3 and 11.4 baselines, I find +FUNC:_ZSt10from_charsPKcS0_RdSt12chars_format@@GLIBCXX_3.4.29 +FUNC:_ZSt10from_charsPKcS0_ReSt12chars_format@@GLIBCXX_3.4.29 +FUNC:_ZSt10from_charsPKcS0_RfSt12chars_format@@GLIBCXX_3.4.29 i.e. std::from_chars(char const*, char const*, double&, std::chars_format) and similarly for long double, float. Those are from from src/c++17/floating_from_chars.cc and only defined if _GLIBCXX_HAVE_USELOCALE, i.e. depend on the XPG7 addition. Given that only Solaris 11.4 supports XPG7, I've taken the 11.3 baselines to avoid having separate ones for 11.3 and 11.4. Tested on i386-pc-solaris2.11 and sparc-sun-solaris2.11 (sparc and x86, 32 and 64-bit, 11.3 and 11.4). 2021-02-10 Rainer Orth <ro@CeBiTec.Uni-Bielefeld.DE> libstdc++-v3: * config/abi/post/i386-solaris/baseline_symbols.txt: Regenerate. * config/abi/post/i386-solaris/amd64/baseline_symbols.txt: Likewise. * config/abi/post/sparc-solaris/baseline_symbols.txt: Likewise. * config/abi/post/sparc-solaris/sparcv9/baseline_symbols.txt: Likewise.
2021-02-25libstdc++: Update baseline symbols for {aarch64,ia64,m68k,riscv64}-linuxAndreas Schwab4-0/+462
libstdc++-v3/ * config/abi/post/aarch64-linux-gnu/baseline_symbols.txt: Update. * config/abi/post/ia64-linux-gnu/baseline_symbols.txt: Update. * config/abi/post/m68k-linux-gnu/baseline_symbols.txt: Update. * config/abi/post/riscv64-linux-gnu/baseline_symbols.txt: Update.
2021-02-24libstdc++: Define std::to_chars overloads for __ieee128 [PR 98389]Jonathan Wakely3-3/+5
This adds overloads of std::to_chars for powerpc64's __ieee128, so that std::to_chars can be used for long double when -mabi=ieeelongdouble is in used. Eventually we'll want to extend these new overloads to work for __float128 on all targets that support that type. For now, we're only doing it for powerpc64 when the new long double type is supported in parallel to the old long double type. Additionally the existing std::to_chars overloads for long double are given the right symbol version, resolving PR libstdc++/98389. libstdc++-v3/ChangeLog: PR libstdc++/98389 * config/abi/pre/gnu.ver (GLIBCXX_3.4.29): Do not match to_chars symbols for long double arguments mangled as 'g'. * config/os/gnu-linux/ldbl-extra.ver: Likewise. * config/os/gnu-linux/ldbl-ieee128-extra.ver: Likewise. * src/c++17/Makefile.am [GLIBCXX_LDBL_ALT128_COMPAT_TRUE]: Use -mabi=ibmlongdouble for floating_to_chars.cc. * src/c++17/Makefile.in: Regenerate. * src/c++17/floating_to_chars.cc (floating_type_traits_binary128): New type defining type traits of IEEE binary128 format. (floating_type_traits<__float128>): Define specialization. (floating_type_traits<long double>): Define in terms of floating_type_traits_binary128 when appropriate. (floating_to_shortest_scientific): Handle __float128. (sprintf_ld): New function template for printing a long double or __ieee128 value using sprintf. (__floating_to_chars_shortest, __floating_to_chars_precision): Use sprintf_ld. (to_chars): Define overloads for __float128.
2021-01-20aix: make ctype_inline.h thread-safe and avoid _OBJ_DATA char subscript.David Edelsohn1-2/+10
g++.dg/warn/Wstringop-overflow-6.C tests for a bogus overflow warning in system headers. This testcase was generating a -Wchar-subscript warning on AIX because ctype_inline.h was subscripting AIX _OBJ_DATA using a char. The _M_table case cast the subscript to unsigned char, but the _OBJ_DATA case did not. The investigation also exposed that AIX has added a thread-safe variant of access to __lc_type that had not been applied to the libstdc++ implementation. This patch casts the subscript to unsigned char and adds the THREAD_SAFE variant. libstdc++ always is compiled with pthreads, but it is good to make the situation explicit and to document the appropriate usage. Bootstrapped on powerpc-ibm-aix7.2.3.0. libstdc++-v3/ChangeLog: * config/os/aix/ctype_inline.h (bool ctype<char>:: is): Cast _OBJ_DATA subscript to unsigned char. Add _THREAD_SAFE access to __lc_type. (const char* ctype<char>:: is): Same.
2021-01-04Update copyright years.Jakub Jelinek155-155/+155
2020-12-17libstdc++: Add floating-point std::to_chars implementationPatrick Palka1-0/+7
This implements the floating-point std::to_chars overloads for float, double and long double. We use the Ryu library to compute the shortest round-trippable fixed and scientific forms for float, double and long double. We also use Ryu for performing explicit-precision fixed and scientific formatting for float and double. For explicit-precision formatting for long double we fall back to using printf. Hexadecimal formatting for float, double and long double is implemented from scratch. The supported long double binary formats are binary64, binary80 (x86 80-bit extended precision), binary128 and ibm128. Much of the complexity of the implementation is in computing the exact output length before handing it off to Ryu (which doesn't do bounds checking). In some cases it's hard to compute the output length beforehand, so in these cases we instead compute an upper bound on the output length and use a sufficiently-sized intermediate buffer only if necessary. Another source of complexity is in the general-with-precision formatting mode, where we need to do zero-trimming of the string returned by Ryu, and where we also take care to avoid having to format the number through Ryu a second time when the general formatting mode resolves to fixed (which we determine by doing a scientific formatting first and inspecting the scientific exponent). We avoid going through Ryu twice by instead transforming the scientific form to the corresponding fixed form via in-place string manipulation. This implementation is non-conforming in a couple of ways: 1. For the shortest hexadecimal formatting, we currently follow the Microsoft implementation's decision to be consistent with the output of printf's '%a' specifier at the expense of sometimes not printing the shortest representation. For example, the shortest hex form for the number 1.08p+0 is 2.1p-1, but we output the former instead of the latter, as does printf. 2. The Ryu routine generic_binary_to_decimal that we use for performing shortest formatting for large floating point types is implemented using the __int128 type, but some targets with a large long double type lack __int128 (e.g. i686), so we can't perform shortest formatting of long double on such targets through Ryu. As a temporary stopgap this patch makes the long double to_chars overloads just dispatch to the double overloads on these targets, which means we lose precision in the output. (We could potentially fix this by writing a specialized version of Ryu's generic_binary_to_decimal routine that uses uint64_t instead of __int128.) [Though I wonder if there's a better way to work around the lack of __int128 on i686 specifically?] 3. Our shortest formatting for __ibm128 doesn't guarantee the round-trip property if the difference between the high- and low-order exponent is large. This is because we treat __ibm128 as if it has a contiguous 105-bit mantissa by merging the mantissas of the high- and low-order parts (using code extracted from glibc), so we potentially lose precision from the low-order part. This seems to be consistent with how glibc printf formats __ibm128. libstdc++-v3/ChangeLog: * config/abi/pre/gnu.ver: Add new exports. * include/std/charconv (to_chars): Declare the floating-point overloads for float, double and long double. * src/c++17/Makefile.am (sources): Add floating_to_chars.cc. * src/c++17/Makefile.in: Regenerate. * src/c++17/floating_to_chars.cc: New file. (to_chars): Define for float, double and long double. * testsuite/20_util/to_chars/long_double.cc: New test.
2020-12-17libstdc++: Test errno macros directly for all targets [PR 93151]Jonathan Wakely3-39/+39
This applies the same changes to the djgpp and mingw versions of error_constants.h as r11-6137 did for the generic version. All of these constants are defined as macros by <errno.h> on these targets, so we can just test the macro directly instead of checking for it at configure time. libstdc++-v3/ChangeLog: * config/os/djgpp/error_constants.h: Test POSIX errno macros directly, instead of corresponding _GLIBCXX_HAVE_EXXX macros. * config/os/mingw32-w64/error_constants.h: Likewise. * config/os/mingw32/error_constants.h: Likewise.
2020-12-16libstdc++: Add C++ runtime support for new 128-bit long double formatJonathan Wakely2-2/+55
This adds support for the new __ieee128 long double format on powerpc64le targets. Most of the complexity comes from wanting a single libstdc++.so library that contains the symbols needed by code compiled with both -mabi=ibmlongdouble and -mabi=ieeelongdouble (and not forgetting -mlong-double-64 as well!) In a few places this just requires an extra overload, for example std::from_chars has to be overloaded for both forms of long double. That can be done in a single translation unit that defines overloads for 'long double' and also '__ieee128', so that user code including <charconv> will be able to link to a definition for either type of long double. Those are the easy cases. The difficult parts are (as for the std::string ABI transition) the I/O and locale facets. In order to be able to write either form of long double to an ostream such as std::cout we need the locale to contain a std::num_put facet that can handle both forms. The same approach is taken as was already done for supporting 64-bit long double and 128-bit long double: adding extra overloads of do_put to the facet class. On targets where the new long double code is enabled, the facets that are registered in the locale at program startup have additional overloads so that they can work with any long double type. Where this fails to work is if user code installs its own facet, which will probably not have the additional overloads and so will only be able to output one or the other type. In practice the number of users expecting to be able to use their own locale facets in code using a mix of -mabi=ibmlongdouble and -mabi=ieeelongdouble is probably close to zero. libstdc++-v3/ChangeLog: * Makefile.in: Regenerate. * config.h.in: Regenerate. * config/abi/pre/gnu.ver: Make patterns less greedy. * config/os/gnu-linux/ldbl-ieee128-extra.ver: New file with patterns for IEEE128 long double symbols. * configure: Regenerate. * configure.ac: Enable alternative 128-bit long double format on powerpc64*-*-linux*. * doc/Makefile.in: Regenerate. * fragment.am: Regenerate. * include/Makefile.am: Set _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT. * include/Makefile.in: Regenerate. * include/bits/c++config: Define inline namespace for new long double symbols. Don't define _GLIBCXX_USE_FLOAT128 when it's the same type as long double. * include/bits/locale_classes.h [_GLIBCXX_LONG_DOUBLE_ALT128_COMPAT] (locale::_Impl::_M_init_extra_ldbl128): Declare new member function. * include/bits/locale_facets.h (_GLIBCXX_NUM_FACETS): Simplify by only counting narrow character facets. (_GLIBCXX_NUM_CXX11_FACETS): Likewise. (_GLIBCXX_NUM_LBDL_ALT128_FACETS): New. [_GLIBCXX_LONG_DOUBLE_ALT128_COMPAT] (num_get::__do_get): Define vtable placeholder for __ibm128 long double type. [_GLIBCXX_LONG_DOUBLE_ALT128_COMPAT && __LONG_DOUBLE_IEEE128__] (num_get::__do_get): Declare vtable placeholder for __ibm128 long double type. [_GLIBCXX_LONG_DOUBLE_ALT128_COMPAT && __LONG_DOUBLE_IEEE128__] (num_put::__do_put): Likewise. * include/bits/locale_facets.tcc [_GLIBCXX_LONG_DOUBLE_ALT128_COMPAT && __LONG_DOUBLE_IEEE128__] (num_get::__do_get, num_put::__do_put): Define. * include/bits/locale_facets_nonio.h [_GLIBCXX_LONG_DOUBLE_ALT128_COMPAT && __LONG_DOUBLE_IEEE128__] (money_get::__do_get): Declare vtable placeholder for __ibm128 long double type. [_GLIBCXX_LONG_DOUBLE_ALT128_COMPAT && __LONG_DOUBLE_IEEE128__] (money_put::__do_put): Likewise. * include/bits/locale_facets_nonio.tcc [_GLIBCXX_LONG_DOUBLE_ALT128_COMPAT && __LONG_DOUBLE_IEEE128__] (money_get::__do_get, money_put::__do_put): Define. * include/ext/numeric_traits.h [_GLIBCXX_LONG_DOUBLE_ALT128_COMPAT] (__numeric_traits<__ibm128>, __numeric_traits<__ieee128>): Define. * libsupc++/Makefile.in: Regenerate. * po/Makefile.in: Regenerate. * python/Makefile.in: Regenerate. * src/Makefile.am: Add compatibility-ldbl-alt128.cc and compatibility-ldbl-alt128-cxx11.cc sources and recipes for objects. * src/Makefile.in: Regenerate. * src/c++11/Makefile.in: Regenerate. * src/c++11/compatibility-ldbl-alt128-cxx11.cc: New file defining symbols using the old 128-bit long double format, for the cxx11 ABI. * src/c++11/compatibility-ldbl-alt128.cc: Likewise, for the gcc4-compatible ABI. * src/c++11/compatibility-ldbl-facets-aliases.h: New header for long double compat aliases. * src/c++11/cow-locale_init.cc: Add comment. * src/c++11/cxx11-locale-inst.cc: Define C and C_is_char unconditionally. * src/c++11/cxx11-wlocale-inst.cc: Add sanity check. Include locale-inst.cc directly, not via cxx11-locale-inst.cc. * src/c++11/locale-inst-monetary.h: New header for monetary category instantiations. * src/c++11/locale-inst-numeric.h: New header for numeric category instantiations. * src/c++11/locale-inst.cc: Include new headers for monetary, numeric, and long double definitions. * src/c++11/wlocale-inst.cc: Remove long double compat aliases that are defined in new header now. * src/c++17/Makefile.am: Use -mabi=ibmlongdouble for floating_from_chars.cc. * src/c++17/Makefile.in: Regenerate. * src/c++17/floating_from_chars.cc (from_chars_impl): Add if-constexpr branch for __ieee128. (from_chars): Overload for __ieee128. * src/c++20/Makefile.in: Regenerate. * src/c++98/Makefile.in: Regenerate. * src/c++98/locale_init.cc (num_facets): Adjust calculation. (locale::_Impl::_Impl(size_t)): Call _M_init_extra_ldbl128. * src/c++98/localename.cc (num_facets): Adjust calculation. (locale::_Impl::_Impl(const char*, size_t)): Call _M_init_extra_ldbl128. * src/filesystem/Makefile.in: Regenerate. * testsuite/Makefile.in: Regenerate. * testsuite/util/testsuite_abi.cc: Add new symbol versions. Allow new symbols to be added to GLIBCXX_IEEE128_3.4.29 and CXXABI_IEEE128_1.3.13 too. * testsuite/26_numerics/complex/abi_tag.cc: Add u9__ieee128 to regex matching expected symbols.
2020-12-16libstdc++: Test errno macros directly, not via autoconf [PR 93151]Jonathan Wakely1-14/+14
This fixes a bug caused by a mismatch between the macros defined by <errno.h> when GCC is built and the macros defined by <errno.h> when users include <system_error>. If the user code is compiled with _XOPEN_SOURCE defined to 500 or 600, Darwin suppresses the ENOTRECOVERABLE and EOWNERDEAD macros, which are not defined by SUSv3 (aka POSIX.1-2001). Since POSIX requires the errno macros to be macros (and not variables or enumerators) we can just test for them directly using the preprocessor. That means that <system_error> will match what is actuallydefined when it's included, not what was defined when GCC was built. With that change there is no need for the GLIBCXX_CHECK_SYSTEM_ERROR configure checks and they can be removed. libstdc++-v3/ChangeLog: PR libstdc++/93151 * acinclude.m4 (GLIBCXX_CHECK_SYSTEM_ERROR): Remove. * configure.ac: Regenerate. * config/os/generic/error_constants.h: Test POSIX errno macros directly, instead of corresponding _GLIBCXX_HAVE_EXXX macros. * testsuite/19_diagnostics/headers/system_error/errc_std_c++0x.cc: Likewise. * testsuite/19_diagnostics/headers/system_error/93151.cc: New test.
2020-12-15libstdc++: Support libc with stdio-only I/O in libstdc++Keith Packard1-5/+41
The current libstdc++ basic_file_stdio.cc code assumes a POSIX API underneath the stdio implementation provided by the host libc. This means that the host must provide a fairly broad POSIX file API, including read, write, open, close, lseek and ioctl. This patch changes basic_file_stdio.cc to only use basic ANSI-C stdio functions, allowing it to be used with libc implementations like picolibc which may not have a POSIX operating system underneath. This is enabled by a new --enable-cstdio=stdio_pure configure option. Aided-by: Jonathan Wakely <jwakely@redhat.com> Signed-off-by: Keith Packard <keithp@keithp.com> libstdc++-v3/ChangeLog: * acinclude.m4 (GLIBCXX_ENABLE_CSTDIO): Allow "stdio_pure" option and define _GLIBCXX_USE_PURE_STDIO when it is used. Also add "stdio_posix" option as an alias for "stdio". * config/io/basic_file_stdio.cc [_GLIBCXX_USE_PURE_STDIO]: Only use defined stdio entry points for all I/O operations, without direct calls to underlying POSIX functions. * config.h.in: Regenerate. * configure: Regenerate.
2020-12-03libstdc++: Update powerpc-linux baselines for GCC 10.1Jonathan Wakely2-0/+34
This should have been done before the GCC 10.1 release. libstdc++-v3/ChangeLog: * config/abi/post/powerpc-linux-gnu/baseline_symbols.txt: Update. * config/abi/post/powerpc64-linux-gnu/32/baseline_symbols.txt: Update.
2020-11-19libstdc++: Avoid calling undefined __gthread_self weak symbol [PR 95989]Jonathan Wakely1-0/+12
Since glibc 2.27 the pthread_self symbol has been defined in libc rather than libpthread. Because we only call pthread_self through a weak alias it's possible for statically linked executables to end up without a definition of pthread_self. This crashes when trying to call an undefined weak symbol. We can use the __GLIBC_PREREQ version check to detect the version of glibc where pthread_self is no longer in libpthread, and call it directly rather than through the weak reference. It would be better to check for pthread_self in libc during configure instead of hardcoding the __GLIBC_PREREQ check. That would be complicated by the fact that prior to glibc 2.27 libc.a didn't have the pthread_self symbol, but libc.so.6 did. The configure checks would need to try to link both statically and dynamically, and the result would depend on whether the static libc.a happens to be installed during configure (which could vary between different systems using the same version of glibc). Doing it properly is left for a future date, as that will be needed anyway after glibc moves all pthread symbols from libpthread to libc. When that happens we should revisit the whole approach of using weak symbols for pthread symbols. For the purposes of std::this_thread::get_id() we call pthread_self() directly when using glibc 2.27 or later. Otherwise, if __gthread_active_p() is true then we know the libpthread symbol is available so we call that. Otherwise, we are single-threaded and just use ((__gthread_t)1) as the thread ID. An undesirable consequence of this change is that code compiled prior to the change might inline the old definition of this_thread::get_id() which always returns (__gthread_t)1 in a program that isn't linked to libpthread. Code compiled after the change will use pthread_self() and so get a real TID. That could result in the main thread having different thread::id values in different translation units. This seems acceptable, as there are not expected to be many uses of thread::id in programs that aren't linked to libpthread. An earlier version of this patch also changed __gthread_self() to use __GLIBC_PREREQ(2, 27) and only use the weak symbol for older glibc. Tha might still make sense to do, but isn't needed by libstdc++ now. libstdc++-v3/ChangeLog: PR libstdc++/95989 * config/os/gnu-linux/os_defines.h (_GLIBCXX_NATIVE_THREAD_ID): Define new macro to get reliable thread ID. * include/bits/std_thread.h: (this_thread::get_id): Use new macro if it's defined. * testsuite/30_threads/jthread/95989.cc: New test. * testsuite/30_threads/this_thread/95989.cc: New test.
2020-11-10libstdc++: Avoid bad_alloc exceptions when changing localesJonathan Wakely1-15/+34
For the --enable-clocale=generic configuration, the current code can fail with a bad_alloc exception. This patch uses the nothrow version of operator new and reports allocation failures by setting failbit in the iostate variable. * config/locale/generic/c_locale.cc (__set_C_locale()): New function to set the "C" locale and return the name of the previous locale. (__convert_to_v<float>, __convert_to_v<double>) (__convert_to_v<long double>): Use __set_C_locale and set failbit on error.
2020-11-10libstdc++: Add remaining C++20 additions to <sstream> [P0408R7]Jonathan Wakely1-3/+18
This adds the new overloads of basic_stringbuf::str, and the corresponding overloads to basic_istringstream, basic_ostringstream and basic_stringstream. libstdc++-v3/ChangeLog: * config/abi/pre/gnu.ver (GLIBCXX_3.4.21): Tighten patterns. (GLIBCXX_3.4.29): Export new symbols. * include/bits/alloc_traits.h (__allocator_like): New concept. * include/std/sstream (basic_stringbuf::swap): Add exception specification. (basic_stringbuf::str() const): Add ref-qualifier. Use new _M_high_mark function. (basic_stringbuf::str(const SAlloc&) const): Define new function. (basic_stringbuf::str() &&): Likewise. (basic_stringbuf::str(const basic_string<C,T,SAlloc>&)): Likewise. (basic_stringbuf::str(basic_string<C,T,Alloc>&&)): Likewise. (basic_stringbuf::view() const): Use _M_high_mark. (basic_istringstream::str, basic_ostringstream::str) (basic_stringstream::str): Define new overloads. * src/c++20/sstream-inst.cc (basic_stringbuf::str) (basic_istringstream::str, basic_ostringstream::str) (basic_stringstream::str): Explicit instantiation definitions for new overloads. * testsuite/27_io/basic_istringstream/view/char/1.cc: Add more checks. * testsuite/27_io/basic_istringstream/view/wchar_t/1.cc: Likewise. * testsuite/27_io/basic_ostringstream/view/char/1.cc: Likewise. * testsuite/27_io/basic_ostringstream/view/wchar_t/1.cc: Likewise. * testsuite/27_io/basic_stringstream/view/char/1.cc: Likewise. * testsuite/27_io/basic_stringstream/view/wchar_t/1.cc: Likewise. * testsuite/27_io/basic_istringstream/str/char/2.cc: New test. * testsuite/27_io/basic_istringstream/str/wchar_t/2.cc: New test. * testsuite/27_io/basic_ostringstream/str/char/3.cc: New test. * testsuite/27_io/basic_ostringstream/str/wchar_t/3.cc: New test. * testsuite/27_io/basic_stringbuf/str/char/4.cc: New test. * testsuite/27_io/basic_stringbuf/str/wchar_t/4.cc: New test. * testsuite/27_io/basic_stringstream/str/char/5.cc: New test. * testsuite/27_io/basic_stringstream/str/wchar_t/5.cc.cc: New test.
2020-11-06libstdc++: Fix symbol version conflict in linker scriptJonathan Wakely1-1/+2
The change in r11-4748-50b840ac5e1d6534e345c3fee9a97ae45ced6bc7 causes a build error on Solaris, due to the new explicit instantiation matching patterns for two different symbol versions. libstdc++-v3/ChangeLog: * config/abi/pre/gnu.ver (GLIBCXX_3.4.21): Tighten up patterns for basic_stringbuf that refer to __xfer_bufptrs.
2020-11-05libstdc++: Export basic_stringbuf constructor [PR 97729]Jonathan Wakely1-0/+1
libstdc++-v3/ChangeLog: PR libstdc++/97729 * config/abi/pre/gnu.ver (GLIBCXX_3.4.29): Add exports. * src/c++20/sstream-inst.cc (basic_stringbuf): Instantiate private constructor taking __xfer_bufptrs.
2020-11-03libstdc++: Add mising gnu-versioned-namespace symbolsFrançois Dumont1-0/+4
libstdc++-v3/ChangeLog: * config/abi/pre/gnu-versioned-namespace.ver: Add __istream_extract and _Safe_local_iterator_base::_M_attach_single symbols.
2020-11-03libstdc++: Rewrite std::call_once to use futexes [PR 66146]Jonathan Wakely1-0/+5
The current implementation of std::call_once uses pthread_once, which only meets the C++ requirements when compiled with support for exceptions. For most glibc targets and all non-glibc targets, pthread_once does not work correctly if the init_routine exits via an exception. The pthread_once_t object is left in the "active" state, and any later attempts to run another init_routine will block forever. This change makes std::call_once work correctly for Linux targets, by replacing the use of pthread_once with a futex, based on the code from __cxa_guard_acquire. For both glibc and musl, the Linux implementation of pthread_once is already based on futexes, and pthread_once_t is just a typedef for int, so this change does not alter the layout of std::once_flag. By choosing the values for the int appropriately, the new code is even ABI compatible. Code that calls the old implementation of std::call_once will use pthread_once to manipulate the int, while new code will use the new std::once_flag members to manipulate it, but they should interoperate correctly. In both cases, the int is initially zero, has the lowest bit set when there is an active execution, and equals 2 after a successful returning execution. The difference with the new code is that exceptional exceptions are correctly detected and the int is reset to zero. The __cxa_guard_acquire code (and musl's pthread_once) use an additional state to say there are other threads waiting. This allows the futex wake syscall to be skipped if there is no contention. Glibc doesn't use a waiter bit, so we have to unconditionally issue the wake in order to be compatible with code calling the old std::call_once that uses Glibc's pthread_once. If we know that we're using musl (and musl's pthread_once doesn't change) it would be possible to set a waiting state and check for it in std::once_flag::_M_finish(bool), but this patch doesn't do that. This doesn't fix the bug for non-linux targets. A similar approach could be used for targets where we know the definition of pthread_once_t is a mutex and an integer. We could make once_flag._M_activate() use pthread_mutex_lock on the mutex member within the pthread_once_t, and then only set the integer if the execution finishes, and then unlock the mutex. That would require careful study of each target's pthread_once implementation and that work is left for a later date. This also fixes PR 55394 because pthread_once is no longer needed, and PR 84323 because the fast path is now just an atomic load. As a consequence of the new implementation that doesn't use pthread_once, we can also make std::call_once work for targets with no gthreads support. The code for the single-threaded implementation follows the same methods as on Linux, but with no need for atomics or futexes. libstdc++-v3/ChangeLog: PR libstdc++/55394 PR libstdc++/66146 PR libstdc++/84323 * config/abi/pre/gnu.ver (GLIBCXX_3.4.29): Add new symbols. * include/std/mutex [!_GLIBCXX_HAS_GTHREADS] (once_flag): Define even when gthreads is not supported. (once_flag::_M_once) [_GLIBCXX_HAVE_LINUX_FUTEX]: Change type from __gthread_once_t to int. (once_flag::_M_passive(), once_flag::_M_activate()) (once_flag::_M_finish(bool), once_flag::_Active_execution): Define new members for futex and non-threaded implementation. [_GLIBCXX_HAS_GTHREADS] (once_flag::_Prepare_execution): New RAII helper type. (call_once): Use new members of once_flag. * src/c++11/mutex.cc (std::once_flag::_M_activate): Define. (std::once_flag::_M_finish): Define. * testsuite/30_threads/call_once/39909.cc: Do not require gthreads. * testsuite/30_threads/call_once/49668.cc: Likewise. * testsuite/30_threads/call_once/60497.cc: Likewise. * testsuite/30_threads/call_once/call_once1.cc: Likewise. * testsuite/30_threads/call_once/dr2442.cc: Likewise. * testsuite/30_threads/call_once/once_flag.cc: Add test for constexpr constructor. * testsuite/30_threads/call_once/66146.cc: New test. * testsuite/30_threads/call_once/constexpr.cc: Removed. * testsuite/30_threads/once_flag/cons/constexpr.cc: Removed.
2020-10-29libstdc++: Fix linker script to remove conflicting patternsJonathan Wakely1-3/+3
This should fix a bootstrap error on Solaris, due to some of the new symbols matching old patterns as well as new ones. libstdc++-v3/ChangeLog: * config/abi/pre/gnu.ver (GLIBCXX_3.4.21): Tighten patterns for old <sstream> symbols some more.
2020-10-28libstdc++: Fix linker scriptJonathan Wakely1-47/+11
libstdc++-v3/ChangeLog: * config/abi/pre/gnu.ver (GLIBCXX_3.4.29): Remove duplicate patterns. (CXXABI_1.3.13): Restore missing piece.
2020-10-28libstdc++: Implement C++20 features for <sstream>Thomas Rodgers1-13/+95
New ctors and ::view() accessor for - * basic_stingbuf * basic_istringstream * basic_ostringstream * basic_stringstreamm New ::get_allocator() accessor for basic_stringbuf. libstdc++-v3/ChangeLog: * acinclude.m4 (glibcxx_SUBDIRS): Add src/c++20. * config/abi/pre/gnu.ver (GLIBCXX_3.4.29): New symbols. * configure: Regenerate. * include/std/sstream: (basic_stringbuf::basic_stringbuf(allocator const&)): New constructor. (basic_stringbuf::basic_stringbuf(openmode, allocator const&)): Likewise. (basic_stringbuf::basic_stringbuf(basic_string&&, openmode)): Likewise. (basic_stringbuf::basic_stringbuf(basic_stringbuf&&, allocator const&)): Likewise. (basic_stringbuf::get_allocator()): New method. (basic_stringbuf::view()): Likewise. (basic_istringstream::basic_istringstream(basic_string&&, openmode)): New constructor. (basic_istringstream::basic_istringstream(openmode, allocator const&)): Likewise (basic_istringstream::view()): New method. (basic_ostringstream::basic_ostringstream(basic_string&&, openmode)): New constructor. (basic_ostringstream::basic_ostringstream(openmode, allocator const&)): Likewise (basic_ostringstream::view()): New method. (basic_stringstream::basic_stringstream(basic_string&&, openmode)): New constructor. (basic_stringstream::basic_stringstream(openmode, allocator const&)): Likewise (basic_stringstream::view()): New method. * src/Makefile.in: Add c++20 directory. * src/Makefile.am: Regenerate. * src/c++20/Makefile.am: Add makefile for new sub-directory. * src/c++20/Makefile.in: Generate. * src/c++20/sstream-inst.cc: New file defining explicit instantiations for basic_stringbuf, basic_istringstream, basic_ostringstream, and basic_stringstream member functions added in C++20. * testsuite/27_io/basic_stringbuf/cons/char/2.cc: New test. * testsuite/27_io/basic_stringbuf/cons/wchar_t/2.cc: Likewise. * testsuite/27_io/basic_stringbuf/view/char/1.cc: Likewise. * testsuite/27_io/basic_stringbuf/view/wchar_t/1.cc: Likewise. * testsuite/27_io/basic_istringstream/cons/char/1.cc: Likewise. * testsuite/27_io/basic_istringstream/cons/wchar_t/1.cc: Likewise. * testsuite/27_io/basic_istringstream/view/char/1.cc: Likewise. * testsuite/27_io/basic_istringstream/view/wchar_t/1.cc: Likewise. * testsuite/27_io/basic_ostringstream/cons/char/1.cc: Likewise. * testsuite/27_io/basic_ostringstream/cons/wchar_t/1.cc: Likewise. * testsuite/27_io/basic_ostringstream/view/char/1.cc: Likewise. * testsuite/27_io/basic_ostringstream/view/wchar_t/1.cc: Likewise. * testsuite/27_io/basic_stringstream/cons/char/1.cc: Likewise. * testsuite/27_io/basic_stringstream/cons/wchar_t/1.cc: Likewise. * testsuite/27_io/basic_stringstream/view/char/1.cc: Likewise. * testsuite/27_io/basic_stringstream/view/wchar_t/1.cc: Likewise.
2020-10-28libstdc++: Override BUFSIZ for Windows targets [PR 94268]Jonathan Wakely2-0/+6
This replaces uses of BUFSIZ with a new _GLIBCXX_BUFSIZ macro that can be overridden in target-specific config headers. That allows the mingw and mingw-w64 targets to override it, because BUFSIZ is apparently defined to 512, resulting in poor performance. The MSVCRT stdio apparently uses 4096, so we use that too. libstdc++-v3/ChangeLog: PR libstdc++/94268 * config/os/mingw32-w64/os_defines.h (_GLIBCXX_BUFSIZ): Define. * config/os/mingw32/os_defines.h (_GLIBCXX_BUFSIZ): Define. * include/bits/fstream.tcc: Use _GLIBCXX_BUFSIZ instead of BUFSIZ. * include/ext/stdio_filebuf.h: Likewise. * include/std/fstream (_GLIBCXX_BUFSIZ): Define.
2020-10-11aix: add FAT library support for libstdc++fs.aClément Chigot1-3/+8
Make libstdc++fs.a a 32/64 bit FAT library. It is too complicated for the FAT library Makefile fragment to determine if --enable-libstdcxx-filesystem-ts has been enabled. This patch checks the existence of libstdc++fs.a at build time and adds the complementary object file if it was built. libstdc++-v3/Changelog: 2020-10-11 Clement Chigot <clement.chigot@atos.net> * config/os/aix/t-aix: Add complementary mode object file to libstdc++fs.a
2020-10-06libstdc++: Inline std::exception_ptr members [PR 90295]Jonathan Wakely1-0/+9
This inlines most members of std::exception_ptr so that all operations on a null exception_ptr can be optimized away. This benefits code like std::future and coroutines where an exception_ptr object is present to cope with exceptional cases, but is usually not used and remains null. Since those functions were previously non-inline we have to continue to export them from the library, for objects that were compiled against the old headers and expect to find definitions in the library. In order to inline the copy constructor and destructor we need to export the _M_addref() and _M_release() members that increment/decrement the reference count when copying/destroying a non-null exception_ptr. The copy ctor and dtor check for null and don't call _M_addref and _M_release unless they need to. The checks for null pointers in _M_addref and _M_release are still needed because old code might call them without checking for null first. But we can use __builtin_expect to predict that they are usually called for the non-null case. libstdc++-v3/ChangeLog: PR libstdc++/90295 * config/abi/pre/gnu.ver (CXXABI_1.3.13): New symbol version. (exception_ptr::_M_addref(), exception_ptr::_M_release()): Export symbols. * libsupc++/eh_ptr.cc (exception_ptr::exception_ptr()): Remove out-of-line definition. (exception_ptr::exception_ptr(const exception_ptr&)): Likewise. (exception_ptr::~exception_ptr()): Likewise. (exception_ptr::operator=(const exception_ptr&)): Likewise. (exception_ptr::swap(exception_ptr&)): Likewise. (exception_ptr::_M_addref()): Add branch prediction. * libsupc++/exception_ptr.h (exception_ptr::operator bool): Add noexcept. [!_GLIBCXX_EH_PTR_COMPAT] (operator==, operator!=): Define inline as hidden friends. Remove declarations at namespace scope. (exception_ptr::exception_ptr()): Define inline. (exception_ptr::exception_ptr(const exception_ptr&)): Likewise. (exception_ptr::~exception_ptr()): Likewise. (exception_ptr::operator=(const exception_ptr&)): Likewise. (exception_ptr::swap(exception_ptr&)): Likewise. * testsuite/util/testsuite_abi.cc: Add CXXABI_1.3.13. * testsuite/18_support/exception_ptr/90295.cc: New test.
2020-10-05libstdc++: Make allocators throw bad_array_new_length on overflow [LWG 3190]Jonathan Wakely1-0/+3
std::allocator and std::pmr::polymorphic_allocator should throw std::bad_array_new_length from their allocate member functions if the number of bytes required cannot be represented in std::size_t. libstdc++-v3/ChangeLog: * config/abi/pre/gnu.ver: Add new symbol. * include/bits/functexcept.h (__throw_bad_array_new_length): Declare new function. * include/ext/malloc_allocator.h (malloc_allocator::allocate): Throw bad_array_new_length for impossible sizes (LWG 3190). * include/ext/new_allocator.h (new_allocator::allocate): Likewise. * include/std/memory_resource (polymorphic_allocator::allocate) (polymorphic_allocator::allocate_object): Use new function, __throw_bad_array_new_length. * src/c++11/functexcept.cc (__throw_bad_array_new_length): Define. * testsuite/20_util/allocator/lwg3190.cc: New test.
2020-10-01libstdc++: Fix test_and_acquire for EABIJonathan Wakely1-1/+1
libstdc++-v3/ChangeLog: * config/cpu/arm/cxxabi_tweaks.h (_GLIBCXX_GUARD_TEST_AND_ACQUIRE): Do not try to dereference return value of __atomic_load_n.
2020-09-30libstdc++: Fix test_and_acquire / set_and_release for EABI guard variablesJonathan Wakely1-1/+6
The default definitions of _GLIBCXX_GUARD_TEST_AND_ACQUIRE and _GLIBCXX_GUARD_SET_AND_RELEASE in libsupc++/guard.cc only work for the generic (IA64) ABI, because they test/set the first byte of the guard variable. For EABI we need to use the least significant bit, which means using the first byte is wrong for big endian targets. This has been wrong since r224411, but previously it only caused poor performance. The _GLIBCXX_GUARD_TEST_AND_ACQUIRE at the very start of __cxa_guard_acquire would always return false even if the initialization was actually complete. Before my r11-3484 change the atomic compare exchange would have loaded the correct value, and then returned 0 as expected when the initialization is complete. After my change, in the single-threaded case there is no redundant check for init being complete, because I foolishly assumed that the check at the start of the function actually worked. The default definition of _GLIBCXX_GUARD_SET_AND_RELEASE is also wrong for big endian EABI, but appears to work because it sets the wrong bit but then the buggy TEST_AND_ACQUIRE tests that wrong bit as well. Also, the buggy SET_AND_RELEASE macro is only used for targets with threads enabled but no futex syscalls. This should fix the regressions introduced by my patch, by defining custom versions of the TEST_AND_ACQUIRE and SET_AND_RELEASE macros that are correct for EABI. libstdc++-v3/ChangeLog: * config/cpu/arm/cxxabi_tweaks.h (_GLIBCXX_GUARD_TEST_AND_ACQUIRE): (_GLIBCXX_GUARD_SET_AND_RELEASE): Define for EABI.
2020-09-27aix: Use $(AR) without -X32_64 to build FAT libraries.Clément Chigot1-6/+6
AIX FAT libraries should be built with the version of AR chosen by configure. The GNU Make $(AR) variable includes the AIX -X32_64 option needed by the default Makefile rules to accept both 32 bit and 64 bit object files. The -X32_64 option conflicts with ar archiving objects of the same name used to build FAT libraries. This patch changes the Makefile fragments for AIX FAT libraries to use $(AR), but strips the -X32_64 option from the Make variable. libgcc/ChangeLog: 2020-09-27 Clement Chigot <clement.chigot@atos.net> * config/rs6000/t-slibgcc-aix: Use $(AR) without -X32_64. libatomic/ChangeLog: 2020-09-27 Clement Chigot <clement.chigot@atos.net> * config/t-aix: Use $(AR) without -X32_64. libgomp/ChangeLog: 2020-09-27 Clement Chigot <clement.chigot@atos.net> * config/t-aix: Use $(AR) without -X32_64. libstdc++-v3/ChangeLog: 2020-09-27 Clement Chigot <clement.chigot@atos.net> * config/os/aix/t-aix: Use $(AR) without -X32_64. libgfortran/ChangeLog: 2020-09-27 Clement Chigot <clement.chigot@atos.net> * config/t-aix: Use $(AR) without -X32_64.
2020-09-11libstdc++: Support futex waiting on chrono::steady_clock directlyMike Crowe1-4/+6
The user-visible effect of this change is for std::future::wait_until to use CLOCK_MONOTONIC when passed a timeout of std::chrono::steady_clock type. This makes it immune to any changes made to the system clock CLOCK_REALTIME. Add an overload of __atomic_futex_unsigned::_M_load_and_text_until_impl that accepts a std::chrono::steady_clock, and correctly passes this through to __atomic_futex_unsigned_base::_M_futex_wait_until_steady which uses CLOCK_MONOTONIC for the timeout within the futex system call. These functions are mostly just copies of the std::chrono::system_clock versions with small tweaks. Prior to this commit, a std::chrono::steady timeout would be converted via std::chrono::system_clock which risks reducing or increasing the timeout if someone changes CLOCK_REALTIME whilst the wait is happening. (The commit immediately prior to this one increases the window of opportunity for that from a short period during the calculation of a relative timeout, to the entire duration of the wait.) FUTEX_WAIT_BITSET was added in kernel v2.6.25. If futex reports ENOSYS to indicate that this operation is not supported then the code falls back to using clock_gettime(2) to calculate a relative time to wait for. I believe that I've added this functionality in a way that it doesn't break ABI compatibility, but that has made it more verbose and less type safe. I believe that it would be better to maintain the timeout as an instance of the correct clock type all the way down to a single _M_futex_wait_until function with an overload for each clock. The current scheme of separating out the seconds and nanoseconds early risks accidentally calling the wait function for the wrong clock. Unfortunately, doing this would break code that compiled against the old header. libstdc++-v3/ChangeLog: * config/abi/pre/gnu.ver: Update for addition of __atomic_futex_unsigned_base::_M_futex_wait_until_steady. * include/bits/atomic_futex.h (__atomic_futex_unsigned_base): Add comments to clarify that _M_futex_wait_until and _M_load_and_test_until use CLOCK_REALTIME. (__atomic_futex_unsigned_base::_M_futex_wait_until_steady) (__atomic_futex_unsigned_base::_M_load_and_text_until_steady): New member functions that use CLOCK_MONOTONIC. (__atomic_futex_unsigned_base::_M_load_and_test_until_impl) (__atomic_futex_unsigned_base::_M_load_when_equal_until): Add overloads that accept a steady_clock time_point and use the new member functions. * src/c++11/futex.cc: Include headers required for clock_gettime. (futex_clock_monotonic_flag): New constant to tell futex to use CLOCK_MONOTONIC to match existing futex_clock_realtime_flag. (futex_clock_monotonic_unavailable): New global to store the result of trying to use CLOCK_MONOTONIC. (__atomic_futex_unsigned_base::_M_futex_wait_until_steady): Add new variant of _M_futex_wait_until that uses CLOCK_MONOTONIC to support waiting using steady_clock.
2020-08-18aix: Support libsupc++ as a FAT libraryDavid Edelsohn1-0/+3
Build libstdc++++ static library libsupc++.a as a FAT 32/64 bit library. libstdc++-v3/ChangeLog: 2020-08-18 David Edelsohn <dje.gcc@gmail.com> Clement Chigot <clement.chigot@atos.net> * config/os/aix/t-aix: Add complementary mode object files to libsupc++.a
2020-08-07libstdc++: Fix linker script patterns for 32-bit targetsJonathan Wakely1-3/+3
When making the patterns less greedy I forgot to use [jmy] for unsigned integer parameters. libstdc++-v3/ChangeLog: * config/abi/pre/gnu.ver: Fix wildcards for wstring symbols.
2020-08-06libstdc++: Implement P0966 std::string::reserve should not shrinkAndrew Luo1-3/+14
Remove ability for reserve(n) to reduce a string's capacity. Add a new reserve() overload that makes a shrink-to-fit request, and make shrink_to_fit() use that. libstdc++-v3/ChangeLog: 2020-07-30 Andrew Luo <andrewluotechnologies@outlook.com> Jonathan Wakely <jwakely@redhat.com> * config/abi/pre/gnu.ver (GLIBCXX_3.4): Use less greedy patterns for basic_string members. (GLIBCXX_3.4.29): Export new basic_string::reserve symbols. * doc/xml/manual/status_cxx2020.xml: Update P0966 status. * include/bits/basic_string.h (shrink_to_fit()): Call reserve(). (reserve(size_type)): Remove default argument. (reserve()): Declare new overload. [!_GLIBCXX_USE_CXX11_ABI] (shrink_to_fit, reserve): Likewise. * include/bits/basic_string.tcc (reserve(size_type)): Remove support for shrinking capacity. (reserve()): Perform shrink-to-fit operation. [!_GLIBCXX_USE_CXX11_ABI] (reserve): Likewise. * testsuite/21_strings/basic_string/capacity/1.cc: Adjust to reflect new behavior. * testsuite/21_strings/basic_string/capacity/char/1.cc: Likewise. * testsuite/21_strings/basic_string/capacity/char/18654.cc: Likewise. * testsuite/21_strings/basic_string/capacity/char/2.cc: Likewise. * testsuite/21_strings/basic_string/capacity/wchar_t/1.cc: Likewise. * testsuite/21_strings/basic_string/capacity/wchar_t/18654.cc: Likewise. * testsuite/21_strings/basic_string/capacity/wchar_t/2.cc: Likewise.
2020-08-05libstdc++: Replace operator>>(istream&, char*) [LWG 2499]Jonathan Wakely1-0/+5
P0487R1 resolved LWG 2499 for C++20 by removing the operator>> overloads that have high risk of buffer overflows. They were replaced by equivalents that only accept a reference to an array, and so can guarantee not to write past the end of the array. In order to support both the old and new functionality, this patch introduces a new overloaded __istream_extract function which takes a maximum length. The new operator>> overloads use the array size as the maximum length. The old overloads now use __builtin_object_size to determine the available buffer size if available (which requires -O2) or use numeric_limits<streamsize>::max()/sizeof(char_type) otherwise. This is a change in behaviour, as the old overloads previously always used numeric_limits<streamsize>::max(), without considering sizeof(char_type) and without attempting to prevent overflows. Because they now do little more than call __istream_extract, the old operator>> overloads are very small inline functions. This means there is no advantage to explicitly instantiating them in the library (in fact that would prevent the __builtin_object_size checks from ever working). As a result, the explicit instantiation declarations can be removed from the header. The explicit instantiation definitions are still needed, for backwards compatibility with existing code that expects to link to the definitions in the library. While working on this change I noticed that src/c++11/istream-inst.cc has the following explicit instantiation definition: template istream& operator>>(istream&, char*); This had no effect (and so should not have been present in that file), because there was an explicit specialization declared in <istream> and defined in src/++98/istream.cc. However, this change removes the explicit specialization, and now the explicit instantiation definition is necessary to ensure the symbol gets defined in the library. libstdc++-v3/ChangeLog: * config/abi/pre/gnu.ver (GLIBCXX_3.4.29): Export new symbols. * include/bits/istream.tcc (__istream_extract): New function template implementing both of operator>>(istream&, char*) and operator>>(istream&, char(&)[N]). Add explicit instantiation declaration for it. Remove explicit instantiation declarations for old function templates. * include/std/istream (__istream_extract): Declare. (operator>>(basic_istream<C,T>&, C*)): Define inline and simply call __istream_extract. (operator>>(basic_istream<char,T>&, signed char*)): Likewise. (operator>>(basic_istream<char,T>&, unsigned char*)): Likewise. (operator>>(basic_istream<C,T>&, C(7)[N])): Define for LWG 2499. (operator>>(basic_istream<char,T>&, signed char(&)[N])): Likewise. (operator>>(basic_istream<char,T>&, unsigned char(&)[N])): Likewise. * include/std/streambuf (basic_streambuf): Declare char overload of __istream_extract as a friend. * src/c++11/istream-inst.cc: Add explicit instantiation definition for wchar_t overload of __istream_extract. Remove explicit instantiation definitions of old operator>> overloads for versioned-namespace build. * src/c++98/istream.cc (operator>>(istream&, char*)): Replace with __istream_extract(istream&, char*, streamsize). * testsuite/27_io/basic_istream/extractors_character/char/3.cc: Do not use variable-length array. * testsuite/27_io/basic_istream/extractors_character/char/4.cc: Do not run test for C++20. * testsuite/27_io/basic_istream/extractors_character/char/9555-ic.cc: Do not test writing to pointers for C++20. * testsuite/27_io/basic_istream/extractors_character/char/9826.cc: Use array instead of pointer. * testsuite/27_io/basic_istream/extractors_character/wchar_t/3.cc: Do not use variable-length array. * testsuite/27_io/basic_istream/extractors_character/wchar_t/4.cc: Do not run test for C++20. * testsuite/27_io/basic_istream/extractors_character/wchar_t/9555-ic.cc: Do not test writing to pointers for C++20. * testsuite/27_io/basic_istream/extractors_character/char/lwg2499.cc: New test. * testsuite/27_io/basic_istream/extractors_character/char/lwg2499_neg.cc: New test. * testsuite/27_io/basic_istream/extractors_character/char/overflow.cc: New test. * testsuite/27_io/basic_istream/extractors_character/wchar_t/lwg2499.cc: New test. * testsuite/27_io/basic_istream/extractors_character/wchar_t/lwg2499_neg.cc: New test.
2020-07-20libstdc++: Add std::from_chars for floating-point typesJonathan Wakely2-0/+11
This adds the missing std::from_chars overloads for floating-point types, as required for C++17 conformance. The implementation is a hack and not intended to be used in the long term. Rather than parsing the string directly, this determines the initial portion of the string that matches the pattern determined by the chars_format parameter, then creates a NTBS to be parsed by strtod (or strtold or strtof). Because creating a NTBS requires allocating memory, but std::from_chars is noexcept, we need to be careful to minimise allocation. Even after being careful, allocation failure is still possible, and so a non-conforming std::no_more_memory error code might be returned. Because strtod et al depend on the current locale, but std::from_chars does not, we change the current thread's locale to "C" using newlocale and uselocale before calling strtod, and restore it afterwards. Because strtod doesn't have the equivalent of a std::chars_format parameter, it has to examine the input to determine the format in use, even though the std::from_chars code has already parsed it once (or twice for large input strings!) By replacing the use of strtod we could avoid allocation, avoid changing locale, and use optimised code paths specific to each std::chars_format case. We would also get more portable behaviour, rather than depending on the presence of uselocale, and on any bugs or quirks of the target libc's strtod. Replacing strtod is a project for a later date. libstdc++-v3/ChangeLog: * acinclude.m4 (libtool_VERSION): Bump version. * config.h.in: Regenerate. * config/abi/pre/gnu.ver: Add GLIBCXX_3.4.29 version and new exports. * config/os/gnu-linux/ldbl-extra.ver: Add _GLIBCXX_LDBL_3.4.29 version and new export. * configure: Regenerate. * configure.ac: Check for <xlocale.h> and uselocale. * crossconfig.m4: Add macro or checks for uselocale. * include/std/charconv (from_chars): Declare overloads for float, double, and long double. * src/c++17/Makefile.am: Add new file. * src/c++17/Makefile.in: Regenerate. * src/c++17/floating_from_chars.cc: New file. (from_chars): Define for float, double, and long double. * testsuite/20_util/from_chars/1_c++20_neg.cc: Prune extra diagnostics caused by new overloads. * testsuite/20_util/from_chars/1_neg.cc: Likewise. * testsuite/20_util/from_chars/2.cc: Check leading '+'. * testsuite/20_util/from_chars/4.cc: New test. * testsuite/20_util/from_chars/5.cc: New test. * testsuite/util/testsuite_abi.cc: Add new symbol versions.
generated by cgit v1.1 at 2025-01-04 01:06:14 +0000