commit: 4bbea521152678132cf0b02e3a152481523b3078 Author: Sam James <sam <AT> gentoo <DOT> org> AuthorDate: Mon Jun 3 01:19:54 2024 +0000 Commit: Sam James <sam <AT> gentoo <DOT> org> CommitDate: Mon Jun 3 01:20:45 2024 +0000 URL: https://gitweb.gentoo.org/repo/gentoo.git/commit/?id=4bbea521
dev-libs/boost: fix aliasing violation in boost::container Note that we have to crank the subslot for this. I've added a fudge .1 which we should drop on 1.86.0. Closes: https://bugs.gentoo.org/933289 Bug: https://github.com/freeorion/freeorion/issues/4949 Bug: https://github.com/boostorg/container/issues/252 Bug: https://github.com/boostorg/container/issues/281 Bug: https://bugs.gentoo.org/932780 Bug: https://bugs.gentoo.org/931587 Signed-off-by: Sam James <sam <AT> gentoo.org> dev-libs/boost/boost-1.85.0-r1.ebuild | 348 ++++++++++++++++++ .../files/boost-1.85.0-container-aliasing.patch | 408 +++++++++++++++++++++ 2 files changed, 756 insertions(+) diff --git a/dev-libs/boost/boost-1.85.0-r1.ebuild b/dev-libs/boost/boost-1.85.0-r1.ebuild new file mode 100644 index 000000000000..aff57dceec4b --- /dev/null +++ b/dev-libs/boost/boost-1.85.0-r1.ebuild @@ -0,0 +1,348 @@ +# Copyright 1999-2024 Gentoo Authors +# Distributed under the terms of the GNU General Public License v2 + +EAPI=8 + +# Keep an eye on both of these after releases for patches: +# * https://www.boost.org/patches/ +# * https://www.boost.org/users/history/version_${MY_PV}.html +# (e.g. https://www.boost.org/users/history/version_1_83_0.html) +# Note that the latter may sometimes feature patches not on the former too. + +# FIXME: cleanup subslot after 1.85.0 + +PYTHON_COMPAT=( python3_{10..12} ) + +inherit flag-o-matic multiprocessing python-r1 toolchain-funcs multilib-minimal + +MY_PV="$(ver_rs 1- _)" + +DESCRIPTION="Boost Libraries for C++" +HOMEPAGE="https://www.boost.org/"; +SRC_URI="https://boostorg.jfrog.io/artifactory/main/release/${PV}/source/boost_${MY_PV}.tar.bz2"; +S="${WORKDIR}/${PN}_${MY_PV}" + +LICENSE="Boost-1.0" +SLOT="0/${PV}.1" # ${PV} instead of the major version due to bug 486122 +KEYWORDS="~alpha ~amd64 ~arm ~arm64 ~hppa ~ia64 ~loong ~m68k ~mips ~ppc ~ppc64 ~riscv ~s390 ~sparc ~x86 ~amd64-linux ~x86-linux ~arm64-macos ~ppc-macos ~x64-macos ~x64-solaris" +IUSE="bzip2 +context debug doc icu lzma +nls mpi numpy python +stacktrace tools zlib zstd" +REQUIRED_USE="python? ( ${PYTHON_REQUIRED_USE} )" +# the tests will never fail because these are not intended as sanity +# tests at all. They are more a way for upstream to check their own code +# on new compilers. Since they would either be completely unreliable +# (failing for no good reason) or completely useless (never failing) +# there is no point in having them in the ebuild to begin with. +RESTRICT="test" + +RDEPEND=" + bzip2? ( app-arch/bzip2:=[${MULTILIB_USEDEP}] ) + icu? ( dev-libs/icu:=[${MULTILIB_USEDEP}] ) + !icu? ( virtual/libiconv[${MULTILIB_USEDEP}] ) + lzma? ( app-arch/xz-utils:=[${MULTILIB_USEDEP}] ) + mpi? ( virtual/mpi[${MULTILIB_USEDEP},cxx,threads] ) + python? ( + ${PYTHON_DEPS} + numpy? ( dev-python/numpy:=[${PYTHON_USEDEP}] ) + ) + zlib? ( sys-libs/zlib:=[${MULTILIB_USEDEP}] ) + zstd? ( app-arch/zstd:=[${MULTILIB_USEDEP}] )" +DEPEND="${RDEPEND}" +BDEPEND=">=dev-build/b2-5.0.0" + +PATCHES=( + "${FILESDIR}"/${PN}-1.81.0-disable_icu_rpath.patch + "${FILESDIR}"/${PN}-1.79.0-build-auto_index-tool.patch + "${FILESDIR}"/${PN}-1.85.0-bcp-filesystem.patch + "${FILESDIR}"/${PN}-1.85.0-python-numpy-2.patch + "${FILESDIR}"/${PN}-1.85.0-container-aliasing.patch +) + +create_user-config.jam() { + local user_config_jam="${BUILD_DIR}"/user-config.jam + if [[ -s ${user_config_jam} ]]; then + einfo "${user_config_jam} already exists, skipping configuration" + return + else + einfo "Creating configuration in ${user_config_jam}" + fi + + local compiler compiler_version compiler_executable="$(tc-getCXX)" + compiler="gcc" + compiler_version="$(gcc-version)" + + if use mpi; then + local mpi_configuration="using mpi ;" + fi + + cat > "${user_config_jam}" <<- __EOF__ || die + using ${compiler} : ${compiler_version} : ${compiler_executable} : <cflags>"${CPPFLAGS} ${CFLAGS}" <cxxflags>"${CPPFLAGS} ${CXXFLAGS}" <linkflags>"${LDFLAGS}" <archiver>"$(tc-getAR)" <ranlib>"$(tc-getRANLIB)" ; + ${mpi_configuration} + __EOF__ + + if multilib_native_use python; then + append_to_user_config() { + local py_config + if tc-is-cross-compiler; then + py_config="using python : ${EPYTHON#python} : : ${ESYSROOT}/usr/include/${EPYTHON} : ${ESYSROOT}/usr/$(get_libdir) ;" + else + py_config="using python : ${EPYTHON#python} : ${PYTHON} : $(python_get_includedir) ;" + fi + echo "${py_config}" >> "${user_config_jam}" || die + } + python_foreach_impl append_to_user_config + fi + + if multilib_native_use python && use numpy; then + einfo "Enabling support for NumPy extensions in Boost.Python" + else + einfo "Disabling support for NumPy extensions in Boost.Python" + + # Boost.Build does not allow for disabling of numpy + # extensions, thereby leading to automagic numpy + # https://github.com/boostorg/python/issues/111#issuecomment-280447482 + sed \ + -e 's/\[ unless \[ python\.numpy \] : <build>no \]/<build>no/g' \ + -i "${BUILD_DIR}"/libs/python/build/Jamfile || die + fi +} + +pkg_setup() { + # Bail out on unsupported build configuration, bug #456792 + if [[ -f "${EROOT}"/etc/site-config.jam ]]; then + if ! grep -q 'gentoo\(debug\|release\)' "${EROOT}"/etc/site-config.jam; then + eerror "You are using custom ${EROOT}/etc/site-config.jam without defined gentoorelease/gentoodebug targets." + eerror "Boost can not be built in such configuration." + eerror "Please, either remove this file or add targets from ${EROOT}/usr/share/boost-build/site-config.jam to it." + die "Unsupported target in ${EROOT}/etc/site-config.jam" + fi + fi +} + +src_prepare() { + default + multilib_copy_sources +} + +ejam() { + create_user-config.jam + + local b2_opts=( "--user-config=${BUILD_DIR}/user-config.jam" ) + if multilib_native_use python; then + append_to_b2_opts() { + b2_opts+=( python="${EPYTHON#python}" ) + } + python_foreach_impl append_to_b2_opts + else + b2_opts+=( --without-python ) + fi + b2_opts+=( "$@" ) + + echo b2 "${b2_opts[@]}" >&2 + b2 "${b2_opts[@]}" +} + +src_configure() { + # Workaround for too many parallel processes requested, bug #506064 + [[ "$(makeopts_jobs)" -gt 64 ]] && MAKEOPTS="${MAKEOPTS} -j64" + + # We don't want to end up with -L/usr/lib on our linker lines + # which then gives us lots of + # skipping incompatible /usr/lib/libc.a when searching for -lc + # warnings + [[ -n ${ESYSROOT} ]] && local icuarg="-sICU_PATH=${ESYSROOT}/usr" + + OPTIONS=( + $(usex debug gentoodebug gentoorelease) + "-j$(makeopts_jobs)" + -q + -d+2 + pch=off + $(usex icu "${icuarg}" '--disable-icu boost.locale.icu=off') + $(usev !mpi --without-mpi) + $(usev !nls --without-locale) + $(usev !context '--without-context --without-coroutine --without-fiber') + $(usev !stacktrace --without-stacktrace) + --boost-build="${BROOT}"/usr/share/b2/src + --layout=system + # building with threading=single is currently not possible + # https://svn.boost.org/trac/boost/ticket/7105 + threading=multi + link=shared + # this seems to be the only way to disable compression algorithms + # https://www.boost.org/doc/libs/1_70_0/libs/iostreams/doc/installation.html#boost-build + -sNO_BZIP2=$(usex bzip2 0 1) + -sNO_LZMA=$(usex lzma 0 1) + -sNO_ZLIB=$(usex zlib 0 1) + -sNO_ZSTD=$(usex zstd 0 1) + ) + + if [[ ${CHOST} == *-darwin* ]]; then + # We need to add the prefix, and in two cases this exceeds, so prepare + # for the largest possible space allocation. + append-ldflags -Wl,-headerpad_max_install_names + fi + + # Use C++17 globally as of 1.80 + append-cxxflags -std=c++17 + + if [[ ${CHOST} != *-darwin* ]]; then + # On modern macOS, file I/O is already 64-bit by default, + # there's no support for special options like O_LARGEFILE. + # Thus, LFS must be disabled. + # + # On other systems, we need to enable LFS explicitly for 64-bit + # offsets on 32-bit hosts (#894564) + append-lfs-flags + fi +} + +multilib_src_compile() { + ejam \ + --prefix="${EPREFIX}"/usr \ + "${OPTIONS[@]}" || die + + if multilib_native_use tools; then + pushd tools >/dev/null || die + ejam \ + --prefix="${EPREFIX}"/usr \ + "${OPTIONS[@]}" \ + || die "Building of Boost tools failed" + popd >/dev/null || die + fi +} + +multilib_src_install() { + ejam \ + --prefix="${ED}"/usr \ + --includedir="${ED}"/usr/include \ + --libdir="${ED}"/usr/$(get_libdir) \ + "${OPTIONS[@]}" install || die "Installation of Boost libraries failed" + + if multilib_native_use tools; then + dobin dist/bin/* + + insinto /usr/share + doins -r dist/share/boostbook + fi + + # boost's build system truely sucks for not having a destdir. Because for + # this reason we are forced to build with a prefix that includes the + # DESTROOT, dynamic libraries on Darwin end messed up, referencing the + # DESTROOT instread of the actual EPREFIX. There is no way out of here + # but to do it the dirty way of manually setting the right install_names. + if [[ ${CHOST} == *-darwin* ]]; then + einfo "Working around completely broken build-system(tm)" + local d + for d in "${ED}"/usr/lib/*.dylib; do + if [[ -f ${d} ]]; then + # fix the "soname" + ebegin " correcting install_name of ${d#${ED}}" + install_name_tool -id "/${d#${D}}" "${d}" + eend $? + # fix references to other libs + # these paths look like this: + # bin.v2/libs/thread/build/gcc-12.1/gentoorelease/pch-off/ + # threadapi-pthread/threading-multi/visibility-hidden/ + # libboost_thread.dylib + refs=$(otool -XL "${d}" | \ + sed -e '1d' -e 's/^\t//' | \ + grep "libboost_" | \ + cut -f1 -d' ') + local r + for r in ${refs}; do + # strip path prefix from references, so we obtain + # something like libboost_thread.dylib. + local r_basename=${r##*/} + + ebegin " correcting reference to ${r_basename}" + install_name_tool -change \ + "${r}" \ + "${EPREFIX}/usr/lib/${r_basename}" \ + "${d}" + eend $? + done + fi + done + fi +} + +multilib_src_install_all() { + if ! use numpy; then + rm -r "${ED}"/usr/include/boost/python/numpy* || die + fi + + if use python; then + if use mpi; then + move_mpi_py_into_sitedir() { + python_moduleinto boost + + python_domodule "${ED}"/usr/$(get_libdir)/boost-${EPYTHON}/mpi.so + rm -r "${ED}"/usr/$(get_libdir)/boost-${EPYTHON} || die + + python_optimize + } + python_foreach_impl move_mpi_py_into_sitedir + else + rm -r "${ED}"/usr/include/boost/mpi/python* || die + fi + else + rm -r "${ED}"/usr/include/boost/{python*,mpi/python*,parameter/aux_/python,parameter/python*} || die + fi + + if ! use nls; then + rm -r "${ED}"/usr/include/boost/locale || die + fi + + if ! use context; then + rm -r "${ED}"/usr/include/boost/context || die + rm -r "${ED}"/usr/include/boost/coroutine{,2} || die + rm "${ED}"/usr/include/boost/asio/spawn.hpp || die + fi + + if use doc; then + # find extraneous files that shouldn't be installed + # as part of the documentation and remove them. + find libs/*/* \( -iname 'test' -o -iname 'src' \) -exec rm -rf '{}' + || die + find doc \( -name 'Jamfile.v2' -o -name 'build' -o -name '*.manifest' \) -exec rm -rf '{}' + || die + find tools \( -name 'Jamfile.v2' -o -name 'src' -o -name '*.cpp' -o -name '*.hpp' \) -exec rm -rf '{}' + || die + + docinto html + dodoc *.{htm,html,png,css} + dodoc -r doc libs more tools + + # To avoid broken links + dodoc LICENSE_1_0.txt + + dosym ../../../../include/boost /usr/share/doc/${PF}/html/boost + fi +} + +pkg_preinst() { + # Yay for having symlinks that are nigh-impossible to remove without + # resorting to dirty hacks like these. Removes lingering symlinks + # from the slotted versions. + local symlink + for symlink in "${EROOT}"/usr/include/boost "${EROOT}"/usr/share/boostbook; do + if [[ -L ${symlink} ]]; then + rm -f "${symlink}" || die + fi + done + + # some ancient installs still have boost cruft lying around + # for unknown reasons, causing havoc for reverse dependencies + # Bug: 607734 + rm -rf "${EROOT}"/usr/include/boost-1_[3-5]? || die +} + +pkg_postinst() { + elog "Boost.Regex is *extremely* ABI sensitive. If you get errors such as" + elog + elog " undefined reference to \`boost::re_detail_$(ver_cut 1)0$(ver_cut 2)00::cpp_regex_traits_implementation" + elog " <char>::transform_primary[abi:cxx11](char const*, char const*) const'" + elog + elog "Then you need to recompile Boost and all its reverse dependencies" + elog "using the same toolchain. In general, *every* change of the C++ toolchain" + elog "requires a complete rebuild of the Boost-dependent ecosystem." + elog + elog "See for instance https://bugs.gentoo.org/638138"; +} diff --git a/dev-libs/boost/files/boost-1.85.0-container-aliasing.patch b/dev-libs/boost/files/boost-1.85.0-container-aliasing.patch new file mode 100644 index 000000000000..cfc1215e7023 --- /dev/null +++ b/dev-libs/boost/files/boost-1.85.0-container-aliasing.patch @@ -0,0 +1,408 @@ +https://bugs.gentoo.org/933289 (and https://bugs.gentoo.org/932780, https://bugs.gentoo.org/931587) +https://github.com/freeorion/freeorion/issues/4949 +https://github.com/boostorg/container/issues/252 +https://github.com/boostorg/container/issues/281 +https://github.com/boostorg/container/commit/20ad12f20e661978e90dc7f36d8ab8ac05e5a5a9 + +From 20ad12f20e661978e90dc7f36d8ab8ac05e5a5a9 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Ion=20Gazta=C3=B1aga?= <[email protected]> +Date: Sun, 28 Apr 2024 23:29:59 +0200 +Subject: [PATCH] Remove UB in flat_map implementation when the implementation + has a movable std::pair + +--- a/boost/container/allocator_traits.hpp ++++ b/boost/container/allocator_traits.hpp +@@ -32,6 +32,8 @@ + #include <boost/container/detail/mpl.hpp> + #include <boost/container/detail/type_traits.hpp> //is_empty + #include <boost/container/detail/placement_new.hpp> ++#include <boost/container/detail/is_pair.hpp> ++#include <boost/container/detail/addressof.hpp> + #ifndef BOOST_CONTAINER_DETAIL_STD_FWD_HPP + #include <boost/container/detail/std_fwd.hpp> + #endif +@@ -81,6 +83,144 @@ + + namespace boost { + namespace container { ++namespace dtl { ++ ++#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) ++ ++template<class T, class ...Args> ++BOOST_CONTAINER_FORCEINLINE void construct_type(T *p, BOOST_FWD_REF(Args) ...args) ++{ ++ ::new((void*)p, boost_container_new_t()) T(::boost::forward<Args>(args)...); ++} ++ ++template < class Pair, class KeyType, class ... Args> ++typename dtl::enable_if< dtl::is_pair<Pair>, void >::type ++construct_type ++ (Pair* p, try_emplace_t, BOOST_FWD_REF(KeyType) k, BOOST_FWD_REF(Args) ...args) ++{ ++ construct_type(dtl::addressof(p->first), ::boost::forward<KeyType>(k)); ++ BOOST_CONTAINER_TRY{ ++ construct_type(dtl::addressof(p->second), ::boost::forward<Args>(args)...); ++ } ++ BOOST_CONTAINER_CATCH(...) { ++ typedef typename Pair::first_type first_type; ++ dtl::addressof(p->first)->~first_type(); ++ BOOST_CONTAINER_RETHROW ++ } ++ BOOST_CONTAINER_CATCH_END ++} ++ ++#else ++ ++#define BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_TYPEJ(N) \ ++template<class T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N>\ ++BOOST_CONTAINER_FORCEINLINE \ ++ typename dtl::disable_if_c<dtl::is_pair<T>::value, void >::type \ ++construct_type(T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\ ++{\ ++ ::new((void*)p, boost_container_new_t()) T( BOOST_MOVE_FWD##N );\ ++}\ ++// ++BOOST_MOVE_ITERATE_0TO8(BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_TYPEJ) ++#undef BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_TYPEJ ++ ++#define BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_TYPE(N) \ ++template < class Pair, class KeyType BOOST_MOVE_I##N BOOST_MOVE_CLASS##N>\ ++typename dtl::enable_if< dtl::is_pair<Pair>, void >::type construct_type\ ++ (Pair* p, try_emplace_t, BOOST_FWD_REF(KeyType) k BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\ ++{\ ++ construct_type(dtl::addressof(p->first), ::boost::forward<KeyType>(k));\ ++ BOOST_CONTAINER_TRY{\ ++ construct_type(dtl::addressof(p->second) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\ ++ }\ ++ BOOST_CONTAINER_CATCH(...) {\ ++ typedef typename Pair::first_type first_type;\ ++ dtl::addressof(p->first)->~first_type();\ ++ BOOST_CONTAINER_RETHROW\ ++ }\ ++ BOOST_CONTAINER_CATCH_END\ ++}\ ++// ++BOOST_MOVE_ITERATE_0TO8(BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_TYPE) ++#undef BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_TYPE ++ ++#endif ++ ++template<class T> ++inline ++typename dtl::enable_if<dtl::is_pair<T>, void >::type ++construct_type(T* p) ++{ ++ dtl::construct_type(dtl::addressof(p->first)); ++ BOOST_CONTAINER_TRY{ ++ dtl::construct_type(dtl::addressof(p->second)); ++ } ++ BOOST_CONTAINER_CATCH(...) { ++ typedef typename T::first_type first_type; ++ dtl::addressof(p->first)->~first_type(); ++ BOOST_CONTAINER_RETHROW ++ } ++ BOOST_CONTAINER_CATCH_END ++} ++ ++ ++template<class T, class U> ++inline ++typename dtl::enable_if_c ++ < dtl::is_pair<T>::value ++ , void >::type ++construct_type(T* p, U &u) ++{ ++ dtl::construct_type(dtl::addressof(p->first), u.first); ++ BOOST_CONTAINER_TRY{ ++ dtl::construct_type(dtl::addressof(p->second), u.second); ++ } ++ BOOST_CONTAINER_CATCH(...) { ++ typedef typename T::first_type first_type; ++ dtl::addressof(p->first)->~first_type(); ++ BOOST_CONTAINER_RETHROW ++ } ++ BOOST_CONTAINER_CATCH_END ++} ++ ++template<class T, class U> ++inline ++typename dtl::enable_if_c ++ < dtl::is_pair<typename dtl::remove_reference<T>::type>::value && ++ !boost::move_detail::is_reference<U>::value //This is needed for MSVC10 and ambiguous overloads ++ , void >::type ++construct_type(T* p, BOOST_RV_REF(U) u) ++{ ++ dtl::construct_type(dtl::addressof(p->first), ::boost::move(u.first)); ++ BOOST_CONTAINER_TRY{ ++ dtl::construct_type(dtl::addressof(p->second), ::boost::move(u.second)); ++ } ++ BOOST_CONTAINER_CATCH(...) { ++ typedef typename T::first_type first_type; ++ dtl::addressof(p->first)->~first_type(); ++ BOOST_CONTAINER_RETHROW ++ } ++ BOOST_CONTAINER_CATCH_END ++} ++ ++template<class T, class U, class V> ++inline ++typename dtl::enable_if<dtl::is_pair<T>, void >::type ++construct_type(T* p, BOOST_FWD_REF(U) x, BOOST_FWD_REF(V) y) ++{ ++ dtl::construct_type(dtl::addressof(p->first), ::boost::forward<U>(x)); ++ BOOST_CONTAINER_TRY{ ++ dtl::construct_type(dtl::addressof(p->second), ::boost::forward<V>(y)); ++ } ++ BOOST_CONTAINER_CATCH(...) { ++ typedef typename T::first_type first_type; ++ dtl::addressof(p->first)->~first_type(); ++ BOOST_CONTAINER_RETHROW ++ } ++ BOOST_CONTAINER_CATCH_END ++} ++ ++} //namespace dtl + + #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + +@@ -419,7 +559,7 @@ struct allocator_traits + + template<class T, class ...Args> + inline static void priv_construct(dtl::false_type, Allocator &, T *p, BOOST_FWD_REF(Args) ...args) +- { ::new((void*)p, boost_container_new_t()) T(::boost::forward<Args>(args)...); } ++ { dtl::construct_type(p, ::boost::forward<Args>(args)...); } + #else // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + public: + +@@ -450,7 +590,7 @@ struct allocator_traits + \ + template<class T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\ + inline static void priv_construct(dtl::false_type, Allocator &, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\ +- { ::new((void*)p, boost_container_new_t()) T(BOOST_MOVE_FWD##N); }\ ++ { dtl::construct_type(p BOOST_MOVE_I##N BOOST_MOVE_FWD##N); }\ + // + BOOST_MOVE_ITERATE_0TO8(BOOST_CONTAINER_ALLOCATOR_TRAITS_PRIV_CONSTRUCT_IMPL) + #undef BOOST_CONTAINER_ALLOCATOR_TRAITS_PRIV_CONSTRUCT_IMPL +--- a/boost/container/detail/construct_in_place.hpp ++++ b/boost/container/detail/construct_in_place.hpp +@@ -24,6 +24,7 @@ + #include <boost/container/allocator_traits.hpp> + #include <boost/container/detail/iterators.hpp> + #include <boost/container/detail/value_init.hpp> ++#include <boost/container/detail/is_pair.hpp> + + namespace boost { + namespace container { +@@ -62,9 +63,42 @@ BOOST_CONTAINER_FORCEINLINE void construct_in_place(Allocator &a, T *dest, empla + + //Assignment + ++template<class T, class U> ++BOOST_CONTAINER_FORCEINLINE ++ typename dtl::disable_if_c ++ < dtl::is_pair<typename dtl::remove_reference<T>::type>::value ++ && dtl::is_pair<typename dtl::remove_reference<U>::type>::value ++ , void>::type ++assign_in_place_ref(T &t, BOOST_FWD_REF(U) u) ++{ t = ::boost::forward<U>(u); } ++ ++template<class T, class U> ++BOOST_CONTAINER_FORCEINLINE ++ typename dtl::enable_if_c ++ < dtl::is_pair<typename dtl::remove_reference<T>::type>::value ++ && dtl::is_pair<typename dtl::remove_reference<U>::type>::value ++ , void>::type ++assign_in_place_ref(T &t, const U &u) ++{ ++ assign_in_place_ref(t.first, u.first); ++ assign_in_place_ref(t.second, u.second); ++} ++ ++template<class T, class U> ++BOOST_CONTAINER_FORCEINLINE ++ typename dtl::enable_if_c ++ < dtl::is_pair<typename dtl::remove_reference<T>::type>::value ++ && dtl::is_pair<typename dtl::remove_reference<U>::type>::value ++ , void>::type ++assign_in_place_ref(T &t, BOOST_RV_REF(U) u) ++{ ++ assign_in_place_ref(t.first, ::boost::move(u.first)); ++ assign_in_place_ref(t.second, ::boost::move(u.second)); ++} ++ + template<class DstIt, class InpIt> + BOOST_CONTAINER_FORCEINLINE void assign_in_place(DstIt dest, InpIt source) +-{ *dest = *source; } ++{ assign_in_place_ref(*dest, *source); } + + template<class DstIt, class U> + BOOST_CONTAINER_FORCEINLINE void assign_in_place(DstIt dest, value_init_construct_iterator<U>) +--- a/boost/container/flat_map.hpp ++++ b/boost/container/flat_map.hpp +@@ -48,6 +48,11 @@ + #include <initializer_list> + #endif + ++#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) ++#define BOOST_CONTAINER_STD_PAIR_IS_MOVABLE ++#endif ++ ++ + namespace boost { + namespace container { + +@@ -58,21 +63,37 @@ class flat_multimap; + + namespace dtl{ + ++#if defined(BOOST_CONTAINER_STD_PAIR_IS_MOVABLE) + template<class D, class S> + BOOST_CONTAINER_FORCEINLINE static D &force(S &s) +-{ return *move_detail::force_ptr<D*>(&s); } ++{ return s; } + + template<class D, class S> + BOOST_CONTAINER_FORCEINLINE static const D &force(const S &s) +-{ return *move_detail::force_ptr<const D*>(&s); } ++{ return s; } ++ ++template<class D> ++BOOST_CONTAINER_FORCEINLINE static D force_copy(D s) ++{ return s; } ++ ++#else //!BOOST_CONTAINER_DOXYGEN_INVOKED ++ ++template<class D, class S> ++BOOST_CONTAINER_FORCEINLINE static D &force(S &s) ++{ return *move_detail::launder_cast<D*>(&s); } ++ ++template<class D, class S> ++BOOST_CONTAINER_FORCEINLINE static const D &force(const S &s) ++{ return *move_detail::launder_cast<const D*>(&s); } + + template<class D, class S> + BOOST_CONTAINER_FORCEINLINE static D force_copy(const S &s) + { +- const D *const vp = move_detail::force_ptr<const D *>(&s); ++ const D *const vp = move_detail::launder_cast<const D *>(&s); + D ret_val(*vp); + return ret_val; + } ++#endif //BOOST_CONTAINER_DOXYGEN_INVOKED + + } //namespace dtl{ + +@@ -118,18 +139,27 @@ class flat_map + private: + BOOST_COPYABLE_AND_MOVABLE(flat_map) + //This is the tree that we should store if pair was movable ++ typedef std::pair<Key, T> std_pair_t; + typedef dtl::flat_tree< +- std::pair<Key, T>, ++ std_pair_t, + dtl::select1st<Key>, + Compare, + AllocatorOrContainer> tree_t; + + //This is the real tree stored here. It's based on a movable pair ++ typedef dtl::pair<Key, T> dtl_pair_t; ++ ++ #ifdef BOOST_CONTAINER_STD_PAIR_IS_MOVABLE ++ typedef std_pair_t impl_pair_t; ++ #else ++ typedef dtl_pair_t impl_pair_t; ++ #endif ++ + typedef dtl::flat_tree< +- dtl::pair<Key, T>, ++ impl_pair_t, + dtl::select1st<Key>, + Compare, +- typename dtl::container_or_allocator_rebind<AllocatorOrContainer, dtl::pair<Key, T> >::type ++ typename dtl::container_or_allocator_rebind<AllocatorOrContainer, impl_pair_t >::type + > impl_tree_t; + impl_tree_t m_flat_tree; // flat tree representing flat_map + +@@ -851,7 +881,7 @@ class flat_map + //! @copydoc ::boost::container::flat_set::nth(size_type) const + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW +- { return dtl::force_copy<iterator>(m_flat_tree.nth(n)); } ++ { return dtl::force_copy<const_iterator>(m_flat_tree.nth(n)); } + + //! @copydoc ::boost::container::flat_set::index_of(iterator) + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline +@@ -1099,7 +1129,7 @@ class flat_map + template <class Pair> + inline BOOST_CONTAINER_DOC1ST + ( std::pair<iterator BOOST_MOVE_I bool> +- , typename dtl::enable_if_c<dtl::is_convertible<Pair BOOST_MOVE_I impl_value_type>::value ++ , typename dtl::enable_if_c<dtl::is_convertible<Pair BOOST_MOVE_I dtl_pair_t>::value + BOOST_MOVE_I std::pair<iterator BOOST_MOVE_I bool> >::type) + insert(BOOST_FWD_REF(Pair) x) + { +@@ -1153,7 +1183,7 @@ class flat_map + template <class Pair> + inline BOOST_CONTAINER_DOC1ST + ( iterator +- , typename dtl::enable_if_c<dtl::is_convertible<Pair BOOST_MOVE_I impl_value_type>::value ++ , typename dtl::enable_if_c<dtl::is_convertible<Pair BOOST_MOVE_I dtl_pair_t>::value + BOOST_MOVE_I iterator>::type) + insert(const_iterator p, BOOST_FWD_REF(Pair) x) + { +@@ -1777,17 +1807,24 @@ class flat_multimap + #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + private: + BOOST_COPYABLE_AND_MOVABLE(flat_multimap) ++ typedef std::pair<Key, T> std_pair_t; + typedef dtl::flat_tree< +- std::pair<Key, T>, ++ std_pair_t, + dtl::select1st<Key>, + Compare, + AllocatorOrContainer> tree_t; + //This is the real tree stored here. It's based on a movable pair ++ typedef dtl::pair<Key, T> dtl_pair_t; ++ #ifdef BOOST_CONTAINER_STD_PAIR_IS_MOVABLE ++ typedef std_pair_t impl_pair_t; ++ #else ++ typedef dtl_pair_t impl_pair_t; ++ #endif + typedef dtl::flat_tree< +- dtl::pair<Key, T>, ++ impl_pair_t, + dtl::select1st<Key>, + Compare, +- typename dtl::container_or_allocator_rebind<AllocatorOrContainer, dtl::pair<Key, T> >::type ++ typename dtl::container_or_allocator_rebind<AllocatorOrContainer, impl_pair_t >::type + > impl_tree_t; + impl_tree_t m_flat_tree; // flat tree representing flat_map + +@@ -2388,7 +2425,7 @@ class flat_multimap + //! @copydoc ::boost::container::flat_set::nth(size_type) const + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW +- { return dtl::force_copy<iterator>(m_flat_tree.nth(n)); } ++ { return dtl::force_copy<const_iterator>(m_flat_tree.nth(n)); } + + //! @copydoc ::boost::container::flat_set::index_of(iterator) + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline +@@ -2477,7 +2514,7 @@ class flat_multimap + template<class Pair> + inline BOOST_CONTAINER_DOC1ST + ( iterator +- , typename dtl::enable_if_c<dtl::is_convertible<Pair BOOST_MOVE_I impl_value_type>::value ++ , typename dtl::enable_if_c<dtl::is_convertible<Pair BOOST_MOVE_I dtl_pair_t>::value + BOOST_MOVE_I iterator >::type) + insert(BOOST_FWD_REF(Pair) x) + { return dtl::force_copy<iterator>(m_flat_tree.emplace_equal(boost::forward<Pair>(x))); } +@@ -2514,7 +2551,7 @@ class flat_multimap + template<class Pair> + inline BOOST_CONTAINER_DOC1ST + ( iterator +- , typename dtl::enable_if_c<dtl::is_convertible<Pair BOOST_MOVE_I impl_value_type>::value ++ , typename dtl::enable_if_c<dtl::is_convertible<Pair BOOST_MOVE_I dtl_pair_t>::value + BOOST_MOVE_I iterator>::type) + insert(const_iterator p, BOOST_FWD_REF(Pair) x) + {
