Rename and rework `_LIBCPP_TRIVIAL_PAIR_COPY_CTOR`. Move FreeBSD configuration in-tree.

[EricWF]

Summary

This patch does the following:

• It renames _LIBCPP_TRIVIAL_PAIR_COPY_CTOR to _LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR.
• It automatically enables this option on FreeBSD in ABI V1, since that's the current ABI FreeBSD ships.
• It cleans up the handling of this option in std::pair.

I would like the sign off from the FreeBSD maintainers. They will no longer need to keep their __config changes downstream.

I'm still hoping to come up with a better way to maintain the ABI without needing these constructors.

[dim]

LGTM. Eric, apologies that this took some time to review. I finally dug out my old test cases for the original problem report in FreeBSD, and re-tested them against this patch. (These test cases link against boost, so will be to big to add to the libc++ tests, unfortunately...)

[dim]

@theraven, do you have any other feedback? :)

[theraven]

Looks fine to me, though I wonder if we want to move to the new ABI for FreeBSD11 and use the old one for <=10.

[dim]

In D21329#475105, @theraven wrote:

Looks fine to me, though I wonder if we want to move to the new ABI for FreeBSD11 and use the old one for <=10.

For 11 it is certainly too late now, since it is ABI/API frozen now, and we would still need to find some way of providing backwards compat for applications that were linked against the earlier libc++, which still had the non-trivial pair copy constructor.

[EricWF]

I'm committing this today, meaning it will make it into 3.9, so don't forget to remove your upstream patches before the release :-)

In D21329#476455, @dim wrote:

In D21329#475105, @theraven wrote:

Looks fine to me, though I wonder if we want to move to the new ABI for FreeBSD11 and use the old one for <=10.

For 11 it is certainly too late now, since it is ABI/API frozen now, and we would still need to find some way of providing backwards compat for applications that were linked against the earlier libc++, which still had the non-trivial pair copy constructor.

I can't think of any way to offer backwards compat for this particular ABI break. Looks like FreeBSD is stuck with this until your allowed to take a total ABI break. Does FreeBSD have a plan for when this might happen?

[EricWF]

r275749.

include/__config

 #define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
 // Fix deque iterator type in order to support incomplete types.
 #define _LIBCPP_ABI_INCOMPLETE_TYPES_IN_DEQUE
 // Fix undefined behavior in how std::list stores it's linked nodes.
 #define _LIBCPP_ABI_LIST_REMOVE_NODE_POINTER_UB
 #define _LIBCPP_ABI_FORWARD_LIST_REMOVE_NODE_POINTER_UB
 #define _LIBCPP_ABI_FIX_UNORDERED_CONTAINER_SIZE_TYPE
 #define _LIBCPP_ABI_VARIADIC_LOCK_GUARD
+#elif _LIBCPP_ABI_VERSION == 1
+// Feature macros for disabling pre ABI v1 features. All of these options
+// are deprecated.
+#if defined(__FreeBSD__)
+#define _LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR
+#endif
+#endif
+
+#ifdef _LIBCPP_TRIVIAL_PAIR_COPY_CTOR
+#error "_LIBCPP_TRIVIAL_PAIR_COPY_CTOR" is no longer supported. \
+       use _LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR instead
 #endif
 
 #define _LIBCPP_CONCAT1(_LIBCPP_X,_LIBCPP_Y) _LIBCPP_X##_LIBCPP_Y
 #define _LIBCPP_CONCAT(_LIBCPP_X,_LIBCPP_Y) _LIBCPP_CONCAT1(_LIBCPP_X,_LIBCPP_Y)
 
 #define _LIBCPP_NAMESPACE _LIBCPP_CONCAT(__,_LIBCPP_ABI_VERSION)
 
 

 #if defined(__APPLE__) || defined(__FreeBSD__)
 #define _LIBCPP_HAS_DEFAULTRUNELOCALE
 #endif
 
 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__sun__)
 #define _LIBCPP_WCTYPE_IS_MASK
 #endif
 
-#ifndef _LIBCPP_TRIVIAL_PAIR_COPY_CTOR
-#  define _LIBCPP_TRIVIAL_PAIR_COPY_CTOR 1
-#endif
-
 #ifndef _LIBCPP_STD_VER
 #  if  __cplusplus <= 201103L
 #    define _LIBCPP_STD_VER 11
 #  elif __cplusplus <= 201402L
 #    define _LIBCPP_STD_VER 14
 #  else
 #    define _LIBCPP_STD_VER 15  // current year, or date of c++17 ratification
 #  endif

include/utility

 struct _LIBCPP_TYPE_VIS_ONLY pair
 {
     typedef _T1 first_type;
     typedef _T2 second_type;
 
     _T1 first;
     _T2 second;
 
-    // pair(const pair&) = default;
-    // pair(pair&&) = default;
-
 #ifndef _LIBCPP_HAS_NO_DEFAULT_FUNCTION_TEMPLATE_ARGS
     template <bool _Dummy = true, class = typename enable_if<
         __dependent_type<is_default_constructible<_T1>, _Dummy>::value &&
         __dependent_type<is_default_constructible<_T2>, _Dummy>::value
       >::type>
 #endif
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR pair() : first(), second() {}
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     pair(const _T1& __x, const _T2& __y)
         : first(__x), second(__y) {}
 
     template<class _U1, class _U2>
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
         pair(const pair<_U1, _U2>& __p
 #ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
                  ,typename enable_if<is_convertible<const _U1&, _T1>::value &&
                                     is_convertible<const _U2&, _T2>::value>::type* = 0
 #endif
                                       )
             : first(__p.first), second(__p.second) {}
 
-#if !defined(_LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS) && _LIBCPP_TRIVIAL_PAIR_COPY_CTOR
-    _LIBCPP_INLINE_VISIBILITY
-    pair(const pair& __p) = default;
-#elif !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) || !_LIBCPP_TRIVIAL_PAIR_COPY_CTOR
+#if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
     _LIBCPP_INLINE_VISIBILITY
     pair(const pair& __p)
         _NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value &&
                    is_nothrow_copy_constructible<second_type>::value)
         : first(__p.first),
           second(__p.second)
     {
     }
+
+# ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    pair(pair&& __p) _NOEXCEPT_(is_nothrow_move_constructible<first_type>::value &&
+                                is_nothrow_move_constructible<second_type>::value)
+        : first(_VSTD::forward<first_type>(__p.first)),
+          second(_VSTD::forward<second_type>(__p.second))
+    {
+    }
+# endif
+#elif !defined(_LIBCPP_CXX03_LANG)
+    pair(pair const&) = default;
+    pair(pair&&) = default;
+#else
+  // Use the implicitly declared copy constructor in C++03
 #endif
 
     _LIBCPP_INLINE_VISIBILITY
     pair& operator=(const pair& __p)
         _NOEXCEPT_(is_nothrow_copy_assignable<first_type>::value &&
                    is_nothrow_copy_assignable<second_type>::value)
     {
         first = __p.first;
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template<class _U1, class _U2>
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
         pair(pair<_U1, _U2>&& __p,
                  typename enable_if<is_convertible<_U1, _T1>::value &&
                                     is_convertible<_U2, _T2>::value>::type* = 0)
             : first(_VSTD::forward<_U1>(__p.first)),
               second(_VSTD::forward<_U2>(__p.second)) {}
 
-#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
-    _LIBCPP_INLINE_VISIBILITY
-    pair(pair&& __p) = default;
-#else
-    _LIBCPP_INLINE_VISIBILITY
-    pair(pair&& __p) _NOEXCEPT_(is_nothrow_move_constructible<first_type>::value &&
-                                is_nothrow_move_constructible<second_type>::value)
-        : first(_VSTD::forward<first_type>(__p.first)),
-          second(_VSTD::forward<second_type>(__p.second))
-    {
-    }
-#endif
-
     _LIBCPP_INLINE_VISIBILITY
     pair&
     operator=(pair&& __p) _NOEXCEPT_(is_nothrow_move_assignable<first_type>::value &&
                                      is_nothrow_move_assignable<second_type>::value)
     {
         first = _VSTD::forward<first_type>(__p.first);
         second = _VSTD::forward<second_type>(__p.second);
         return *this;

test/libcxx/utilities/utility/pairs/pairs.pair/trivial_copy_move.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <utility>
+
+// template <class T1, class T2> struct pair
+
+// Doesn't pass due to use of is_trivially_* trait.
+// XFAIL: gcc-4.9
+
+// Test that we properly provide the old non-trivial copy operations
+// when the ABI macro is defined.
+
+#define _LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR
+#include <utility>
+#include <cassert>
+
+#include "test_macros.h"
+
+#if TEST_STD_VER >= 11
+struct Dummy {
+  Dummy(Dummy const&) = delete;
+  Dummy(Dummy &&) = default;
+};
+#endif
+
+int main()
+{
+    typedef std::pair<int, short> P;
+    {
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+    }
+#if TEST_STD_VER >= 11
+    {
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(!std::is_trivially_move_constructible<P>::value, "");
+    }
+    {
+        using P1 = std::pair<Dummy, int>;
+        // This line fails because the non-trivial constructors do not provide
+        // SFINAE.
+        // static_assert(!std::is_copy_constructible<P1>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P1>::value, "");
+        static_assert(std::is_move_constructible<P1>::value, "");
+        static_assert(!std::is_trivially_move_constructible<P1>::value, "");
+    }
+#endif
+}