diff --git a/SOURCES/gcc11-libstdc++-compat.patch b/SOURCES/gcc11-libstdc++-compat.patch index 43c5c9d..cd958c3 100644 --- a/SOURCES/gcc11-libstdc++-compat.patch +++ b/SOURCES/gcc11-libstdc++-compat.patch @@ -11384,7 +11384,7 @@ + --- libstdc++-v3/src/nonshared17/cow-fs_path.cc.libstdc++-compat~ 2021-05-17 12:05:15.746955081 -0400 +++ libstdc++-v3/src/nonshared17/cow-fs_path.cc 2021-05-18 07:06:10.443687154 -0400 -@@ -0,0 +1,118 @@ +@@ -0,0 +1,130 @@ +// Copyright (C) 2019-2021 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free @@ -11408,6 +11408,15 @@ +// . + +#include "../c++17/cow-fs_path.cc" ++asm (".hidden _ZTVSt12codecvt_utf8IwLm1114111ELSt12codecvt_mode0EE"); ++asm (".hidden _ZTVNSt10filesystem4path8_CodecvtIwEE"); ++asm (".hidden _ZTSSt12codecvt_utf8IwLm1114111ELSt12codecvt_mode0EE"); ++asm (".hidden _ZTSNSt10filesystem4path8_CodecvtIwEE"); ++asm (".hidden _ZTISt12codecvt_utf8IwLm1114111ELSt12codecvt_mode0EE"); ++asm (".hidden _ZTINSt10filesystem4path8_CodecvtIwEE"); ++asm (".hidden _ZNSt12codecvt_utf8IwLm1114111ELSt12codecvt_mode0EED0Ev"); ++asm (".hidden _ZNSt12codecvt_utf8IwLm1114111ELSt12codecvt_mode0EED1Ev"); ++asm (".hidden _ZNSt12codecvt_utf8IwLm1114111ELSt12codecvt_mode0EED2Ev"); +asm (".hidden _ZNKSt12__shared_ptrIKNSt10filesystem16filesystem_error5_ImplELN9__gnu_cxx12_Lock_policyE2EE14_M_get_deleterERKSt9type_info"); +asm (".hidden _ZNKSt12__shared_ptrIKNSt10filesystem16filesystem_error5_ImplELN9__gnu_cxx12_Lock_policyE2EE3getEv"); +asm (".hidden _ZNKSt12__shared_ptrIKNSt10filesystem16filesystem_error5_ImplELN9__gnu_cxx12_Lock_policyE2EE6uniqueEv"); @@ -11422,6 +11431,9 @@ +asm (".hidden _ZNSt10filesystem4path5_ListaSERKS1_"); +asm (".hidden _ZNSt10filesystem4path5_ListC2ERKS1_"); +asm (".hidden _ZNSt10filesystem4path5_ListC2Ev"); ++asm (".hidden _ZNSt10filesystem4path8_CodecvtIwED0Ev"); ++asm (".hidden _ZNSt10filesystem4path8_CodecvtIwED1Ev"); ++asm (".hidden _ZNSt10filesystem4path8_CodecvtIwED2Ev"); +asm (".hidden _ZNSt12__shared_ptrIKNSt10filesystem16filesystem_error5_ImplELN9__gnu_cxx12_Lock_policyE2EE4swapERS6_"); +asm (".hidden _ZNSt12__shared_ptrIKNSt10filesystem16filesystem_error5_ImplELN9__gnu_cxx12_Lock_policyE2EE5resetEv"); +asm (".hidden _ZNSt12__shared_ptrIKNSt10filesystem16filesystem_error5_ImplELN9__gnu_cxx12_Lock_policyE2EEaSEOS6_"); @@ -11467,17 +11479,17 @@ +asm (".hidden _ZNKSt10filesystem4path5_List5_Impl4copyEv"); +asm (".hidden _ZNSt10filesystem4path10_S_convertIwEEDaPKT_S4_"); +asm (".hidden _ZNSt10filesystem8__detail24__throw_conversion_errorEv"); -+asm (".hidden _ZTIZNSt10filesystem4path10_S_convertIwEEDaPKT_S4_E5_UCvt"); -+asm (".hidden _ZTSZNSt10filesystem4path10_S_convertIwEEDaPKT_S4_E5_UCvt"); -+asm (".hidden _ZTVZNSt10filesystem4path10_S_convertIwEEDaPKT_S4_E5_UCvt"); -+asm (".hidden _ZZNSt10filesystem4path10_S_convertIwEEDaPKT_S4_EN5_UCvtD0Ev"); -+asm (".hidden _ZZNSt10filesystem4path10_S_convertIwEEDaPKT_S4_EN5_UCvtD1Ev"); -+asm (".hidden _ZZNSt10filesystem4path10_S_convertIwEEDaPKT_S4_EN5_UCvtD2Ev"); +asm (".hidden _ZNSt10filesystem4path5_List5beginEv"); +asm (".hidden _ZNSt10filesystem4path7_Parser4nextEv"); +asm (".hidden _ZNSt10filesystem4pathD1Ev"); +asm (".hidden _ZNSt10filesystem4pathD2Ev"); +#ifndef __i386__ ++//asm (".hidden _ZTVZNSt10filesystem4path10_S_convertIwEEDaPKT_S4_E5_UCvt"); ++//asm (".hidden _ZZNSt10filesystem4path10_S_convertIwEEDaPKT_S4_EN5_UCvtD1Ev"); ++//asm (".hidden _ZZNSt10filesystem4path10_S_convertIwEEDaPKT_S4_EN5_UCvtD0Ev"); ++//asm (".hidden _ZTIZNSt10filesystem4path10_S_convertIwEEDaPKT_S4_E5_UCvt"); ++//asm (".hidden _ZTSZNSt10filesystem4path10_S_convertIwEEDaPKT_S4_E5_UCvt"); ++//asm (".hidden _ZZNSt10filesystem4path10_S_convertIwEEDaPKT_S4_EN5_UCvtD2Ev"); +asm (".hidden _ZNSbIwSt11char_traitsIwESaIwEE6resizeEmw"); +asm (".hidden _ZNSbIwSt11char_traitsIwESaIwEE7reserveEm"); +asm (".hidden _ZNSbIwSt11char_traitsIwESaIwEE9_M_mutateEmmm"); @@ -11610,7 +11622,7 @@ +asm (".hidden _ZNSt10filesystem7__cxx114_Dir7advanceEbRSt10error_code"); +asm (".hidden _ZNSt10filesystem7__cxx114_DirD1Ev"); +asm (".hidden _ZNSt10filesystem7__cxx114_DirD2Ev"); -+#ifdef __x86_64__ ++#if defined(__x86_64__) || defined(__i386__) +asm (".hidden _ZNSt10filesystem9_Dir_base7advanceEbRSt10error_code"); +//asm (".hidden _ZNSt10filesystem9_Dir_baseC1EPKcbRSt10error_code"); +//asm (".hidden _ZNSt10filesystem9_Dir_baseC2EPKcbRSt10error_code"); @@ -11671,7 +11683,7 @@ +#endif --- libstdc++-v3/src/nonshared17/fs_path80.cc.libstdc++-compat~ 2021-05-17 12:05:15.766954365 -0400 +++ libstdc++-v3/src/nonshared17/fs_path80.cc 2021-05-18 07:26:42.069574900 -0400 -@@ -0,0 +1,51 @@ +@@ -0,0 +1,61 @@ +// Copyright (C) 2019-2021 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free @@ -11696,17 +11708,21 @@ + +#define _GLIBCXX_NONSHARED_CXX17_80 +#include "fs_path.cc" -+#if !defined(__powerpc64__) && !defined(__s390x__) && !defined(__i386__) ++asm (".hidden _ZTVSt12codecvt_utf8IwLm1114111ELSt12codecvt_mode0EE"); ++asm (".hidden _ZTVNSt10filesystem7__cxx114path8_CodecvtIwEE"); ++asm (".hidden _ZTSSt12codecvt_utf8IwLm1114111ELSt12codecvt_mode0EE"); ++asm (".hidden _ZTSNSt10filesystem7__cxx114path8_CodecvtIwEE"); ++asm (".hidden _ZTISt12codecvt_utf8IwLm1114111ELSt12codecvt_mode0EE"); ++asm (".hidden _ZTINSt10filesystem7__cxx114path8_CodecvtIwEE"); +asm (".hidden _ZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_"); -+#endif +asm (".hidden _ZNSt10filesystem7__cxx118__detail24__throw_conversion_errorEv"); -+asm (".hidden _ZTIZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_E5_UCvt"); -+asm (".hidden _ZTSZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_E5_UCvt"); -+asm (".hidden _ZTVZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_E5_UCvt"); -+asm (".hidden _ZZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_EN5_UCvtD0Ev"); -+asm (".hidden _ZZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_EN5_UCvtD1Ev"); -+asm (".hidden _ZZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_EN5_UCvtD2Ev"); +asm (".hidden _ZNKSt10filesystem7__cxx114path5_List5_Impl4copyEv"); ++asm (".hidden _ZNSt10filesystem7__cxx114path8_CodecvtIwED0Ev"); ++asm (".hidden _ZNSt10filesystem7__cxx114path8_CodecvtIwED1Ev"); ++asm (".hidden _ZNSt10filesystem7__cxx114path8_CodecvtIwED2Ev"); ++asm (".hidden _ZNSt12codecvt_utf8IwLm1114111ELSt12codecvt_mode0EED0Ev"); ++asm (".hidden _ZNSt12codecvt_utf8IwLm1114111ELSt12codecvt_mode0EED1Ev"); ++asm (".hidden _ZNSt12codecvt_utf8IwLm1114111ELSt12codecvt_mode0EED2Ev"); +#ifdef __i386__ +asm (".hidden _ZNSt12system_errorC1ESt10error_codeRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE"); +asm (".hidden _ZNSt12system_errorC2ESt10error_codeRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE"); @@ -11717,6 +11733,12 @@ +asm (".hidden _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEjc"); +#endif +#ifndef __i386__ ++//asm (".hidden _ZZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_EN5_UCvtD2Ev"); ++//asm (".hidden _ZZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_EN5_UCvtD0Ev"); ++//asm (".hidden _ZTIZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_E5_UCvt"); ++//asm (".hidden _ZTVZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_E5_UCvt"); ++//asm (".hidden _ZZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_EN5_UCvtD1Ev"); ++//asm (".hidden _ZTSZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_E5_UCvt"); +asm (".hidden _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm"); +asm (".hidden _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEmc"); +asm (".hidden _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm"); @@ -11762,7 +11784,7 @@ +asm (".hidden _ZNSt10filesystem4_Dir7advanceEbRSt10error_code"); +asm (".hidden _ZNSt10filesystem4_DirD1Ev"); +asm (".hidden _ZNSt10filesystem4_DirD2Ev"); -+#ifdef __x86_64__ ++#if defined(__x86_64__) || defined(__i386__) +asm (".hidden _ZNSt10filesystem9_Dir_base7advanceEbRSt10error_code"); +//asm (".hidden _ZNSt10filesystem9_Dir_baseC1EPKcbRSt10error_code"); +//asm (".hidden _ZNSt10filesystem9_Dir_baseC2EPKcbRSt10error_code"); @@ -11968,7 +11990,7 @@ + $(OPT_LDFLAGS) $(SECTION_LDFLAGS) $(AM_CXXFLAGS) $(LTLDFLAGS) -o $@ --- libstdc++-v3/src/nonshared17/fs_path.cc.libstdc++-compat~ 2021-05-17 12:05:15.766954365 -0400 +++ libstdc++-v3/src/nonshared17/fs_path.cc 2021-05-18 07:27:17.368310028 -0400 -@@ -0,0 +1,95 @@ +@@ -0,0 +1,93 @@ +// Copyright (C) 2019-2021 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free @@ -12042,18 +12064,16 @@ +asm (".hidden _ZNSt12system_errorC2ESt10error_codeRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE"); +asm (".hidden _ZNSt15__allocated_ptrISaISt23_Sp_counted_ptr_inplaceINSt10filesystem7__cxx1116filesystem_error5_ImplESaIS4_ELN9__gnu_cxx12_Lock_policyE2EEEED1Ev"); +asm (".hidden _ZNSt15__allocated_ptrISaISt23_Sp_counted_ptr_inplaceINSt10filesystem7__cxx1116filesystem_error5_ImplESaIS4_ELN9__gnu_cxx12_Lock_policyE2EEEED2Ev"); -+#if !defined (__aarch64__) && !defined (__x86_64__) +#ifndef __i386__ ++//asm (".hidden _ZZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_EN5_UCvtD0Ev"); ++//asm (".hidden _ZTIZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_E5_UCvt"); ++//asm (".hidden _ZTVZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_E5_UCvt"); ++//asm (".hidden _ZTSZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_E5_UCvt"); +//asm (".hidden _ZNSt10filesystem7__cxx114pathaSISt17basic_string_viewIcSt11char_traitsIcEEEERNSt9enable_ifIXsrSt6__and_IISt6__not_ISt7is_sameINSt9remove_cvIT_E4typeES1_EES9_ISt7is_voidINSt14remove_pointerISC_E4typeEEENS0_8__detail20__constructible_fromISC_vEEEE5valueES1_E4typeERKSC_"); +//asm (".hidden _ZNSt10filesystem7__cxx114pathaSISt17basic_string_viewIcSt11char_traitsIcEEEERNSt9enable_ifIXsrSt6__and_IJSt6__not_ISt7is_sameINSt9remove_cvIT_E4typeES1_EES9_ISt7is_voidINSt14remove_pointerISC_E4typeEEENS0_8__detail20__constructible_fromISC_vEEEE5valueES1_E4typeERKSC_"); ++//asm (".hidden _ZZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_EN5_UCvtD1Ev"); ++//asm (".hidden _ZZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_EN5_UCvtD2Ev"); +#endif -+#endif -+asm (".hidden _ZTIZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_E5_UCvt"); -+asm (".hidden _ZTSZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_E5_UCvt"); -+asm (".hidden _ZTVZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_E5_UCvt"); -+asm (".hidden _ZZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_EN5_UCvtD0Ev"); -+asm (".hidden _ZZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_EN5_UCvtD1Ev"); -+asm (".hidden _ZZNSt10filesystem7__cxx114path10_S_convertIwEEDaPKT_S5_EN5_UCvtD2Ev"); +asm (".hidden _ZNSt10filesystem7__cxx114path5_List5beginEv"); +asm (".hidden _ZNSt10filesystem7__cxx114path7_Parser4nextEv"); +#if !defined(__powerpc64__) && !defined(__s390x__) && !defined(__i386__) diff --git a/SOURCES/libstdc-Check-conversion-from-filesystem-path-to-wide.patch b/SOURCES/libstdc-Check-conversion-from-filesystem-path-to-wide.patch new file mode 100644 index 0000000..668f879 --- /dev/null +++ b/SOURCES/libstdc-Check-conversion-from-filesystem-path-to-wide.patch @@ -0,0 +1,470 @@ +From d308b11fa94728507984b4ccc949219511273ab6 Mon Sep 17 00:00:00 2001 +From: Jonathan Wakely +Date: Fri, 11 Nov 2022 15:22:02 +0000 +Subject: [PATCH] libstdc++: Fix wstring conversions in filesystem::path + [PR95048] + +In commit r9-7381-g91756c4abc1757 I changed filesystem::path to use +std::codecvt for conversions from all wide +strings to UTF-8, instead of using std::codecvt_utf8. This was +done because for 16-bit wchar_t, std::codecvt_utf8 only +supports UCS-2 and not UTF-16. The rationale for the change was sound, +but the actual fix was not. It's OK to use std::codecvt for char16_t or +char32_t, because the specializations for those types always use UTF-8 , +but std::codecvt uses the current locale's +encodings, and the narrow encoding is probably ASCII and can't support +non-ASCII characters. + +The correct fix is to use std::codecvt only for char16_t and char32_t. +For 32-bit wchar_t we could have continued using std::codecvt_utf8 +because that uses UTF-32 which is fine, switching to std::codecvt broke +non-Windows targets with 32-bit wchar_t. For 16-bit wchar_t we did need +to change, but should have changed to std::codecvt_utf8_utf16 +instead, as that always uses UTF-16 not UCS-2. I actually noted that in +the commit message for r9-7381-g91756c4abc1757 but didn't use that +option. Oops. + +This replaces the unconditional std::codecvt +with a type defined via template specialization, so it can vary +depending on the wide character type. The code is also simplified to +remove some of the mess of #ifdef and if-constexpr conditions. + +libstdc++-v3/ChangeLog: + + PR libstdc++/95048 + * include/bits/fs_path.h (path::_Codecvt): New class template + that selects the kind of code conversion done. + (path::_Codecvt): Select based on sizeof(wchar_t). + (_GLIBCXX_CONV_FROM_UTF8): New macro to allow the same code to + be used for Windows and POSIX. + (path::_S_convert(const EcharT*, const EcharT*)): Simplify by + using _Codecvt and _GLIBCXX_CONV_FROM_UTF8 abstractions. + (path::_S_str_convert(basic_string_view, const A&)): + Simplify nested conditions. + * include/experimental/bits/fs_path.h (path::_Cvt): Define + nested typedef controlling type of code conversion done. + (path::_Cvt::_S_wconvert): Use new typedef. + (path::string(const A&)): Likewise. + * testsuite/27_io/filesystem/path/construct/95048.cc: New test. + * testsuite/experimental/filesystem/path/construct/95048.cc: New + test. + +(cherry picked from commit b331bf303bdc1edead41e2b3d11d1a7804b433cf) +--- + libstdc++-v3/include/bits/fs_path.h | 126 ++++++++++-------- + .../include/experimental/bits/fs_path.h | 53 ++++++-- + .../27_io/filesystem/path/construct/95048.cc | 45 +++++++ + .../filesystem/path/construct/95048.cc | 47 +++++++ + 4 files changed, 204 insertions(+), 67 deletions(-) + create mode 100644 libstdc++-v3/testsuite/27_io/filesystem/path/construct/95048.cc + create mode 100644 libstdc++-v3/testsuite/experimental/filesystem/path/construct/95048.cc + +diff --git a/libstdc++-v3/include/bits/fs_path.h b/libstdc++-v3/include/bits/fs_path.h +index 1188e585b14c..029a6f365b3a 100644 +--- a/libstdc++-v3/include/bits/fs_path.h ++++ b/libstdc++-v3/include/bits/fs_path.h +@@ -684,6 +684,8 @@ namespace __detail + _List _M_cmpts; + + struct _Parser; ++ ++ template struct _Codecvt; + }; + + /// @{ +@@ -811,55 +813,72 @@ namespace __detail + size_t _M_pos; + }; + ++ // path::_Codecvt Performs conversions between C and path::string_type. ++ // The native encoding of char strings is the OS-dependent current ++ // encoding for pathnames. FIXME: We assume this is UTF-8 everywhere, ++ // but should use a Windows API to query it. ++ ++ // Converts between native pathname encoding and char16_t or char32_t. ++ template ++ struct path::_Codecvt ++ // Need derived class here because std::codecvt has protected destructor. ++ : std::codecvt<_EcharT, char, mbstate_t> ++ { }; ++ ++ // Converts between native pathname encoding and native wide encoding. ++ // The native encoding for wide strings is the execution wide-character ++ // set encoding. FIXME: We assume that this is either UTF-32 or UTF-16 ++ // (depending on the width of wchar_t). That matches GCC's default, ++ // but can be changed with -fwide-exec-charset. ++ // We need a custom codecvt converting the native pathname encoding ++ // to/from the native wide encoding. ++ template<> ++ struct path::_Codecvt ++ : conditional_t, // UTF-8 <-> UTF-32 ++ std::codecvt_utf8_utf16> // UTF-8 <-> UTF-16 ++ { }; ++ + template + auto + path::_S_convert(const _EcharT* __f, const _EcharT* __l) + { + static_assert(__detail::__is_encoded_char<_EcharT>); + ++#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS ++# define _GLIBCXX_CONV_FROM_UTF8(S) __detail::__wstr_from_utf8(S) ++#else ++# define _GLIBCXX_CONV_FROM_UTF8(S) S ++#endif ++ + if constexpr (is_same_v<_EcharT, value_type>) + return basic_string_view(__f, __l - __f); +-#if !defined _GLIBCXX_FILESYSTEM_IS_WINDOWS && defined _GLIBCXX_USE_CHAR8_T ++#ifdef _GLIBCXX_USE_CHAR8_T + else if constexpr (is_same_v<_EcharT, char8_t>) +- // For POSIX converting from char8_t to char is also 'noconv' +- return string_view(reinterpret_cast(__f), __l - __f); +-#endif +- else + { ++ string_view __str(reinterpret_cast(__f), __l - __f); ++ return _GLIBCXX_CONV_FROM_UTF8(__str); ++ } ++#endif + #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS ++ else if constexpr (is_same_v<_EcharT, char>) ++ { + std::wstring __wstr; +- if constexpr (is_same_v<_EcharT, char>) +- { +- struct _UCvt : std::codecvt +- { } __cvt; +- if (__str_codecvt_in_all(__f, __l, __wstr, __cvt)) +- return __wstr; +- } +-#ifdef _GLIBCXX_USE_CHAR8_T +- else if constexpr (is_same_v<_EcharT, char8_t>) +- { +- const auto __f2 = reinterpret_cast(__f); +- return __detail::__wstr_from_utf8(string_view(__f2, __l - __f)); +- } ++ path::_Codecvt __cvt; ++ if (__str_codecvt_in_all(__f, __l, __wstr, __cvt)) ++ return __wstr; ++ } + #endif +- else // char16_t or char32_t +- { +- struct _UCvt : std::codecvt<_EcharT, char, std::mbstate_t> +- { } __cvt; +- std::string __str; +- if (__str_codecvt_out_all(__f, __l, __str, __cvt)) +- return __detail::__wstr_from_utf8(__str); +- } +-#else // ! windows +- struct _UCvt : std::codecvt<_EcharT, char, std::mbstate_t> +- { } __cvt; ++ else ++ { ++ path::_Codecvt<_EcharT> __cvt; + std::string __str; + if (__str_codecvt_out_all(__f, __l, __str, __cvt)) +- return __str; +-#endif +- __detail::__throw_conversion_error(); ++ return _GLIBCXX_CONV_FROM_UTF8(__str); + } ++ __detail::__throw_conversion_error(); + } ++#undef _GLIBCXX_CONV_FROM_UTF8 + + /// @endcond + +@@ -1028,7 +1047,9 @@ namespace __detail + if (__str.size() == 0) + return _WString(__a); + +-#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS ++#ifndef _GLIBCXX_FILESYSTEM_IS_WINDOWS ++ string_view __u8str = __str; ++#else + // First convert native string from UTF-16 to to UTF-8. + // XXX This assumes that the execution wide-character set is UTF-16. + std::codecvt_utf8_utf16 __cvt; +@@ -1038,35 +1059,30 @@ namespace __detail + _String __u8str{_CharAlloc{__a}}; + const value_type* __wfirst = __str.data(); + const value_type* __wlast = __wfirst + __str.size(); +- if (__str_codecvt_out_all(__wfirst, __wlast, __u8str, __cvt)) { ++ if (!__str_codecvt_out_all(__wfirst, __wlast, __u8str, __cvt)) ++ __detail::__throw_conversion_error(); + if constexpr (is_same_v<_CharT, char>) + return __u8str; // XXX assumes native ordinary encoding is UTF-8. +- else { +- +- const char* __first = __u8str.data(); +- const char* __last = __first + __u8str.size(); +-#else +- const value_type* __first = __str.data(); +- const value_type* __last = __first + __str.size(); +-#endif +- +- // Convert UTF-8 string to requested format. +-#ifdef _GLIBCXX_USE_CHAR8_T +- if constexpr (is_same_v<_CharT, char8_t>) +- return _WString(__first, __last, __a); + else + #endif + { +- // Convert UTF-8 to wide string. +- _WString __wstr(__a); +- struct _UCvt : std::codecvt<_CharT, char, std::mbstate_t> { } __cvt; +- if (__str_codecvt_in_all(__first, __last, __wstr, __cvt)) +- return __wstr; +- } ++ const char* __first = __u8str.data(); ++ const char* __last = __first + __u8str.size(); + +-#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS +- } } ++ // Convert UTF-8 string to requested format. ++#ifdef _GLIBCXX_USE_CHAR8_T ++ if constexpr (is_same_v<_CharT, char8_t>) ++ return _WString(__first, __last, __a); ++ else + #endif ++ { ++ // Convert UTF-8 to wide string. ++ _WString __wstr(__a); ++ path::_Codecvt<_CharT> __cvt; ++ if (__str_codecvt_in_all(__first, __last, __wstr, __cvt)) ++ return __wstr; ++ } ++ } + __detail::__throw_conversion_error(); + } + /// @endcond +diff --git a/libstdc++-v3/include/experimental/bits/fs_path.h b/libstdc++-v3/include/experimental/bits/fs_path.h +index 830b51e45a0f..65d63e433e08 100644 +--- a/libstdc++-v3/include/experimental/bits/fs_path.h ++++ b/libstdc++-v3/include/experimental/bits/fs_path.h +@@ -748,15 +748,48 @@ namespace __detail + template<> + struct path::_Cvt + { ++ // We need this type to be defined because we don't have `if constexpr` ++ // in C++11 and so path::string(const A&) needs to be able to ++ // declare a variable of this type and pass it to __str_codecvt_in_all. ++ using __codecvt_utf8_to_wide = _Cvt; ++ // Dummy overload used for unreachable calls in path::string. ++ template ++ friend bool ++ __str_codecvt_in_all(const char*, const char*, ++ _WStr&, __codecvt_utf8_to_wide&) noexcept ++ { return true; } ++ + template + static string_type + _S_convert(_Iter __first, _Iter __last) + { return string_type{__first, __last}; } + }; + ++ // Performs conversions from _CharT to path::string_type. + template + struct path::_Cvt + { ++ // FIXME: We currently assume that the native wide encoding for wchar_t ++ // is either UTF-32 or UTF-16 (depending on the width of wchar_t). ++ // See comments in for further details. ++ using __codecvt_utf8_to_wchar ++ = typename conditional, // from UTF-32 ++ std::codecvt_utf8_utf16 // from UTF-16 ++ >::type; ++ ++ // Converts from char16_t or char32_t using std::codecvt. ++ // Need derived class here because std::codecvt has protected destructor. ++ struct __codecvt_utf8_to_utfNN : std::codecvt<_CharT, char, mbstate_t> ++ { }; ++ ++ // Convert from native pathname format (assumed to be UTF-8 everywhere) ++ // to the encoding implied by the wide character type _CharT. ++ using __codecvt_utf8_to_wide ++ = typename conditional::value, ++ __codecvt_utf8_to_wchar, ++ __codecvt_utf8_to_utfNN>::type; ++ + #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS + #ifdef _GLIBCXX_USE_CHAR8_T + static string_type +@@ -774,8 +807,7 @@ namespace __detail + static string_type + _S_wconvert(const char* __f, const char* __l, const char*) + { +- using _Cvt = std::codecvt; +- const auto& __cvt = std::use_facet<_Cvt>(std::locale{}); ++ std::codecvt_utf8_utf16 __cvt; + std::wstring __wstr; + if (__str_codecvt_in_all(__f, __l, __wstr, __cvt)) + return __wstr; +@@ -787,8 +819,7 @@ namespace __detail + static string_type + _S_wconvert(const _CharT* __f, const _CharT* __l, const void*) + { +- struct _UCvt : std::codecvt<_CharT, char, std::mbstate_t> +- { } __cvt; ++ __codecvt_utf8_to_wide __cvt; + std::string __str; + if (__str_codecvt_out_all(__f, __l, __str, __cvt)) + { +@@ -819,8 +850,7 @@ namespace __detail + else + #endif + { +- struct _UCvt : std::codecvt<_CharT, char, std::mbstate_t> +- { } __cvt; ++ __codecvt_utf8_to_wide __cvt; + std::string __str; + if (__str_codecvt_out_all(__f, __l, __str, __cvt)) + return __str; +@@ -990,7 +1020,7 @@ namespace __detail + inline std::basic_string<_CharT, _Traits, _Allocator> + path::string(const _Allocator& __a) const + { +- if (is_same<_CharT, value_type>::value) ++ if _GLIBCXX_CONSTEXPR (is_same<_CharT, value_type>::value) + return { _M_pathname.begin(), _M_pathname.end(), __a }; + + using _WString = basic_string<_CharT, _Traits, _Allocator>; +@@ -1026,9 +1056,8 @@ namespace __detail + else + #endif + { +- // Convert UTF-8 to wide string. +- struct _UCvt : std::codecvt<_CharT, char, std::mbstate_t> +- { } __cvt; ++ // Convert UTF-8 to char16_t or char32_t string. ++ typename path::_Cvt<_CharT>::__codecvt_utf8_to_wide __cvt; + const char* __f = __from.data(); + const char* __l = __f + __from.size(); + if (__str_codecvt_in_all(__f, __l, __to, __cvt)) +@@ -1041,14 +1070,14 @@ namespace __detail + if (auto* __p = __dispatch(__u8str, __wstr, is_same<_CharT, char>{})) + return *__p; + } +-#else ++#else // ! Windows + #ifdef _GLIBCXX_USE_CHAR8_T + if constexpr (is_same<_CharT, char8_t>::value) + return _WString(__first, __last, __a); + else + #endif + { +- struct _UCvt : std::codecvt<_CharT, char, std::mbstate_t> { } __cvt; ++ typename path::_Cvt<_CharT>::__codecvt_utf8_to_wide __cvt; + _WString __wstr(__a); + if (__str_codecvt_in_all(__first, __last, __wstr, __cvt)) + return __wstr; +diff --git a/libstdc++-v3/testsuite/27_io/filesystem/path/construct/95048.cc b/libstdc++-v3/testsuite/27_io/filesystem/path/construct/95048.cc +new file mode 100644 +index 000000000000..c1a382d14204 +--- /dev/null ++++ b/libstdc++-v3/testsuite/27_io/filesystem/path/construct/95048.cc +@@ -0,0 +1,45 @@ ++// { dg-do run { target c++17 } } ++ ++// C++17 30.10.8.4.1 path constructors [fs.path.construct] ++ ++#include ++#include ++ ++using std::filesystem::path; ++ ++#define CHECK(E, S) (path(E##S) == path(u8##S)) ++ ++void ++test_wide() ++{ ++ VERIFY( CHECK(L, "\u00E4") ); // PR libstdc++/95048 ++ VERIFY( CHECK(L, "\U0001F4C1") ); // folder ++ VERIFY( CHECK(L, "\U0001F4C2") ); // open folder ++ VERIFY( CHECK(L, "\U0001F4C4") ); // filing cabient ++} ++ ++void ++test_u16() ++{ ++ VERIFY( CHECK(u, "\u00E4") ); // PR libstdc++/95048 ++ VERIFY( CHECK(u, "\U0001F4C1") ); // folder ++ VERIFY( CHECK(u, "\U0001F4C2") ); // open folder ++ VERIFY( CHECK(u, "\U0001F4C4") ); // filing cabient ++} ++ ++void ++test_u32() ++{ ++ VERIFY( CHECK(U, "\u00E4") ); // PR libstdc++/95048 ++ VERIFY( CHECK(U, "\U0001F4C1") ); // folder ++ VERIFY( CHECK(U, "\U0001F4C2") ); // open folder ++ VERIFY( CHECK(U, "\U0001F4C4") ); // filing cabient ++} ++ ++int ++main() ++{ ++ test_wide(); ++ test_u16(); ++ test_u32(); ++} +diff --git a/libstdc++-v3/testsuite/experimental/filesystem/path/construct/95048.cc b/libstdc++-v3/testsuite/experimental/filesystem/path/construct/95048.cc +new file mode 100644 +index 000000000000..b7a93f3c9856 +--- /dev/null ++++ b/libstdc++-v3/testsuite/experimental/filesystem/path/construct/95048.cc +@@ -0,0 +1,47 @@ ++// { dg-options "-lstdc++fs" } ++// { dg-do run { target c++11 } } ++// { dg-require-filesystem-ts "" } ++ ++// 8.4.1 path constructors [path.construct] ++ ++#include ++#include ++ ++using std::experimental::filesystem::path; ++ ++#define CHECK(E, S) (path(E##S) == path(u8##S)) ++ ++void ++test_wide() ++{ ++ VERIFY( CHECK(L, "\u00E4") ); // PR libstdc++/95048 ++ VERIFY( CHECK(L, "\U0001F4C1") ); // folder ++ VERIFY( CHECK(L, "\U0001F4C2") ); // open folder ++ VERIFY( CHECK(L, "\U0001F4C4") ); // filing cabient ++} ++ ++void ++test_u16() ++{ ++ VERIFY( CHECK(u, "\u00E4") ); // PR libstdc++/95048 ++ VERIFY( CHECK(u, "\U0001F4C1") ); // folder ++ VERIFY( CHECK(u, "\U0001F4C2") ); // open folder ++ VERIFY( CHECK(u, "\U0001F4C4") ); // filing cabient ++} ++ ++void ++test_u32() ++{ ++ VERIFY( CHECK(U, "\u00E4") ); // PR libstdc++/95048 ++ VERIFY( CHECK(U, "\U0001F4C1") ); // folder ++ VERIFY( CHECK(U, "\U0001F4C2") ); // open folder ++ VERIFY( CHECK(U, "\U0001F4C4") ); // filing cabient ++} ++ ++int ++main() ++{ ++ test_wide(); ++ test_u16(); ++ test_u32(); ++} +-- +2.39.3 diff --git a/SOURCES/libstdc-Mark-non-exported-function-always_inline.patch b/SOURCES/libstdc-Mark-non-exported-function-always_inline.patch new file mode 100644 index 0000000..25bd6c5 --- /dev/null +++ b/SOURCES/libstdc-Mark-non-exported-function-always_inline.patch @@ -0,0 +1,43 @@ +From 03af8492bee6243a9d10e78fea1a3e423bd5f9cd Mon Sep 17 00:00:00 2001 +From: Jonathan Wakely +Date: Fri, 27 May 2022 12:43:18 +0100 +Subject: [PATCH] libstdc++: Mark non-exported function always_inline + [PR105671] + +This new function was added for gcc 11.1 but is not exported from the +shared library. Depending on inlining decisions, its callers might get +inlined but an external definition be needed for this function. That +then fails to link. + +Since we can't add the export to the gcc-11 release branch now, mark it +always_inline. We can consider exporting it for gcc-13 if/when we bump +the shared library version (and maybe also for gcc-12 which is currently +at the same version as trunk). For now, the attribute will solve the +problem on all affected branches. The function is small enough that +force-inlining it shouldn't cause problems. + +libstdc++-v3/ChangeLog: + + PR libstdc++/105671 + * include/std/sstream (basic_stringbuf::_M_high_mark): Add + always_inline attribute. + +(cherry picked from commit de57440858591a88e8fd7ba2505ca54546c86021) +--- + libstdc++-v3/include/std/sstream | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/libstdc++-v3/include/std/sstream b/libstdc++-v3/include/std/sstream +index f21664100ab8..56555ecd98a1 100644 +--- a/libstdc++-v3/include/std/sstream ++++ b/libstdc++-v3/include/std/sstream +@@ -425,6 +425,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11 + // This might not be the same character as _M_string.end() because + // basic_stringbuf::overflow might have written to unused capacity + // in _M_string without updating its length. ++ __attribute__((__always_inline__)) + char_type* + _M_high_mark() const _GLIBCXX_NOEXCEPT + { +-- +2.39.3 diff --git a/SPECS/gcc.spec b/SPECS/gcc.spec index 9814e48..31908d1 100644 --- a/SPECS/gcc.spec +++ b/SPECS/gcc.spec @@ -138,7 +138,7 @@ Summary: GCC version 11 Name: %{?scl_prefix}gcc Version: %{gcc_version} -Release: %{gcc_release}.1%{?dist} +Release: %{gcc_release}.2%{?dist}.alma.1 # libgcc, libgfortran, libgomp, libstdc++ and crtstuff have # GCC Runtime Exception. License: GPLv3+ and GPLv3+ with exceptions and GPLv2+ with exceptions and LGPLv2+ and BSD @@ -344,6 +344,11 @@ Patch16: gcc11-stringify-__VA_OPT__.patch Patch17: gcc11-stringify-__VA_OPT__-2.patch Patch18: gcc11-Wbidi-chars.patch Patch19: gcc11-dejagnu-multiline.patch +# Patches were taken from upstream: +# https://gcc.gnu.org/git/?p=gcc.git;a=patch;h=03af8492bee6243a9d10e78fea1a3e423bd5f9cd +Patch20: libstdc-Mark-non-exported-function-always_inline.patch +# https://gcc.gnu.org/git/?p=gcc.git;a=patch;h=d308b11fa94728507984b4ccc949219511273ab6 +Patch21: libstdc-Check-conversion-from-filesystem-path-to-wide.patch Patch100: gcc11-fortran-fdec-duplicates.patch Patch101: gcc11-fortran-flogical-as-integer.patch @@ -385,6 +390,9 @@ Patch3012: 0016-Conditionalize-test-for-hashtable-bucket-sizes-on-__.patch Patch3013: 0017-Conditionalize-test-for-PR-libstdc-71181-on-__LIBSTD.patch Patch3014: gcc11-dg-ice-fixes.patch + + + %if 0%{?rhel} > 7 %global nonsharedver 80 %else @@ -719,6 +727,8 @@ to NVidia PTX capable devices if available. %patch17 -p0 -b .stringify-__VA_OPT__-2~ %patch18 -p1 -b .bidi~ %patch19 -p1 -b .dejagnu-multiline~ +%patch20 -p1 -b .libstdc++-mark~ +%patch21 -p1 -b .libstdc++-check~ %patch100 -p1 -b .fortran-fdec-duplicates~ %patch101 -p1 -b .fortran-flogical-as-integer~ @@ -2892,6 +2902,10 @@ fi %endif %changelog +* Fri Oct 20 2023 Eduard Abdullin 11.2.1-9.2.alma.1 +- Apply libstdc-Check-conversion-from-filesystem-path-to-wide.patch +- Apply libstdc-Mark-non-exported-function-always_inline.patch + * Wed Feb 2 2022 Marek Polacek 11.2.1-9.1 - avoid overly-greedy match in dejagnu regexp (#2049712)