Skip to content

Commit e4ab57b

Browse files
philnik777philnik777
committed
[libc++][ABI BREAK] Make std::pair trivially copyable if its members are
1 parent d929351 commit e4ab57b

File tree

4 files changed

+133
-7
lines changed

4 files changed

+133
-7
lines changed

‎libcxx/include/__configuration/abi.h

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -90,7 +90,9 @@
9090
# define _LIBCPP_ABI_USE_WRAP_ITER_IN_STD_ARRAY
9191
# define _LIBCPP_ABI_USE_WRAP_ITER_IN_STD_STRING_VIEW
9292
// Dont' add an inline namespace for `std::filesystem`
93-
# define _LIBCPP_ABI_NO_FILESYSTEM_INLINE_NAMESPACE
93+
# define _LIBCPP_ABI_NO_FILESYSTEM_INLINE_NAMESPACE
94+
// Make a std::pair of trivially copyable types trivially copyable
95+
# define _LIBCPP_ABI_TRIVIALLY_COPYABLE_PAIR
9496
#elif _LIBCPP_ABI_VERSION == 1
9597
# if !(defined(_LIBCPP_OBJECT_FORMAT_COFF) || defined(_LIBCPP_OBJECT_FORMAT_XCOFF))
9698
// Enable compiling copies of now inline methods into the dylib to support

‎libcxx/include/__type_traits/datasizeof.h

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -54,6 +54,7 @@ struct _FirstPaddingByte<_Tp, true> {
5454
// the use as an extension.
5555
_LIBCPP_DIAGNOSTIC_PUSH
5656
_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Winvalid-offsetof")
57+
_LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Winvalid-offsetof")
5758
template <class _Tp>
5859
inline const size_t __datasizeof_v = offsetof(_FirstPaddingByte<_Tp>, __first_padding_byte_);
5960
_LIBCPP_DIAGNOSTIC_POP

‎libcxx/include/__utility/pair.h

Lines changed: 34 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -32,6 +32,7 @@
3232
#include <__type_traits/is_implicitly_default_constructible.h>
3333
#include <__type_traits/is_nothrow_assignable.h>
3434
#include <__type_traits/is_nothrow_constructible.h>
35+
#include <__type_traits/is_reference.h>
3536
#include <__type_traits/is_same.h>
3637
#include <__type_traits/is_swappable.h>
3738
#include <__type_traits/nat.h>
@@ -74,6 +75,30 @@ struct _LIBCPP_TEMPLATE_VIS pair
7475
_LIBCPP_HIDE_FROM_ABI pair(pair const&) = default;
7576
_LIBCPP_HIDE_FROM_ABI pair(pair&&) = default;
7677

78+
// When we are requested for pair to be trivially copyable by the ABI macro, we use defaulted members
79+
// if it is both legal to do it (i.e. no references) and we have a way to actually implement it, which requires
80+
// the __enable_if__ attribute before C++20.
81+
#if defined(_LIBCPP_ABI_TRIVIALLY_COPYABLE_PAIR) && _LIBCPP_STD_VER >= 20
82+
static const bool __has_defaulted_members = !is_reference<first_type>::value && !is_reference<second_type>::value;
83+
84+
_LIBCPP_HIDE_FROM_ABI constexpr pair& operator=(const pair&)
85+
requires __has_defaulted_members
86+
= default;
87+
88+
_LIBCPP_HIDE_FROM_ABI constexpr pair& operator=(pair&&)
89+
requires __has_defaulted_members
90+
= default;
91+
#elif defined(_LIBCPP_ABI_TRIVIALLY_COPYABLE_PAIR) && __has_attribute(__enable_if__)
92+
static const bool __has_defaulted_members = !is_reference<first_type>::value && !is_reference<second_type>::value;
93+
94+
_LIBCPP_HIDE_FROM_ABI pair& operator=(const pair&)
95+
__attribute__((__enable_if__(__has_defaulted_members, ""))) = default;
96+
97+
_LIBCPP_HIDE_FROM_ABI pair& operator=(pair&&) __attribute__((__enable_if__(__has_defaulted_members, ""))) = default;
98+
#else
99+
static const bool __has_defaulted_members = false;
100+
#endif // defined(_LIBCPP_ABI_TRIVIALLY_COPYABLE_PAIR) && __has_attribute(__enable_if__)
101+
77102
#ifdef _LIBCPP_CXX03_LANG
78103
_LIBCPP_HIDE_FROM_ABI pair() : first(), second() {}
79104

@@ -222,18 +247,21 @@ struct _LIBCPP_TEMPLATE_VIS pair
222247
typename __make_tuple_indices<sizeof...(_Args2) >::type()) {}
223248

224249
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair&
225-
operator=(__conditional_t< is_copy_assignable<first_type>::value && is_copy_assignable<second_type>::value,
226-
pair,
227-
__nat> const& __p)
250+
operator=(__conditional_t<
251+
!__has_defaulted_members && is_copy_assignable<first_type>::value && is_copy_assignable<second_type>::value,
252+
pair,
253+
__nat> const& __p)
228254
_NOEXCEPT_(is_nothrow_copy_assignable<first_type>::value&& is_nothrow_copy_assignable<second_type>::value) {
229255
first = __p.first;
230256
second = __p.second;
231257
return *this;
232258
}
233259

234-
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair& operator=(
235-
__conditional_t< is_move_assignable<first_type>::value && is_move_assignable<second_type>::value, pair, __nat>&&
236-
__p)
260+
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair&
261+
operator=(__conditional_t<
262+
!__has_defaulted_members && is_move_assignable<first_type>::value && is_move_assignable<second_type>::value,
263+
pair,
264+
__nat>&& __p)
237265
_NOEXCEPT_(is_nothrow_move_assignable<first_type>::value&& is_nothrow_move_assignable<second_type>::value) {
238266
first = std::forward<first_type>(__p.first);
239267
second = std::forward<second_type>(__p.second);

‎libcxx/test/libcxx/utilities/utility/pairs/pairs.pair/trivially_copyable.compile.pass.cpp

Lines changed: 95 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,95 @@
1+
//===----------------------------------------------------------------------===//
2+
//
3+
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4+
// See https://llvm.org/LICENSE.txt for license information.
5+
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6+
//
7+
//===----------------------------------------------------------------------===//
8+
9+
// UNSUPPORTED: gcc && (c++11 || c++14 || c++17)
10+
11+
#include <type_traits>
12+
#include <utility>
13+
14+
#include "test_macros.h"
15+
16+
struct trivially_copyable {
17+
int arr[4];
18+
};
19+
20+
struct trivially_copyable_no_assignment {
21+
int arr[4];
22+
trivially_copyable_no_assignment& operator=(const trivially_copyable_no_assignment&) = delete;
23+
};
24+
static_assert(std::is_trivially_copyable<trivially_copyable_no_assignment>::value, "");
25+
26+
static_assert(std::is_trivially_copy_constructible<std::pair<trivially_copyable_no_assignment, int> >::value, "");
27+
static_assert(std::is_trivially_move_constructible<std::pair<trivially_copyable_no_assignment, int> >::value, "");
28+
#if TEST_STD_VER >= 11 // This is https://llvm.org/PR90605
29+
static_assert(!std::is_trivially_copy_assignable<std::pair<trivially_copyable_no_assignment, int> >::value, "");
30+
static_assert(!std::is_trivially_move_assignable<std::pair<trivially_copyable_no_assignment, int> >::value, "");
31+
#endif // TEST_STD_VER >= 11
32+
static_assert(std::is_trivially_destructible<std::pair<trivially_copyable_no_assignment, int> >::value, "");
33+
34+
struct trivially_copyable_no_construction {
35+
int arr[4];
36+
trivially_copyable_no_construction() = default;
37+
trivially_copyable_no_construction(const trivially_copyable_no_construction&) = delete;
38+
trivially_copyable_no_construction& operator=(const trivially_copyable_no_construction&) = default;
39+
};
40+
static_assert(std::is_trivially_copyable<trivially_copyable_no_construction>::value, "");
41+
42+
#ifdef _LIBCPP_ABI_TRIVIALLY_COPYABLE_PAIR
43+
static_assert(!std::is_trivially_copy_constructible<std::pair<trivially_copyable_no_construction, int> >::value, "");
44+
static_assert(!std::is_trivially_move_constructible<std::pair<trivially_copyable_no_construction, int> >::value, "");
45+
static_assert(std::is_trivially_copy_assignable<std::pair<trivially_copyable_no_construction, int> >::value, "");
46+
static_assert(std::is_trivially_move_assignable<std::pair<trivially_copyable_no_construction, int> >::value, "");
47+
static_assert(std::is_trivially_destructible<std::pair<trivially_copyable_no_construction, int> >::value, "");
48+
#else // _LIBCPP_ABI_TRIVIALLY_COPYABLE_PAIR
49+
# if TEST_STD_VER >= 11
50+
static_assert(!std::is_trivially_copy_constructible<std::pair<trivially_copyable_no_construction, int> >::value, "");
51+
static_assert(!std::is_trivially_move_constructible<std::pair<trivially_copyable_no_construction, int> >::value, "");
52+
# endif // TEST_STD_VER >= 11
53+
static_assert(!std::is_trivially_copy_assignable<std::pair<trivially_copyable_no_construction, int> >::value, "");
54+
static_assert(!std::is_trivially_move_assignable<std::pair<trivially_copyable_no_construction, int> >::value, "");
55+
static_assert(std::is_trivially_destructible<std::pair<trivially_copyable_no_construction, int> >::value, "");
56+
#endif // _LIBCPP_ABI_TRIVIALLY_COPYABLE_PAIR
57+
58+
static_assert(!std::is_trivially_copyable<std::pair<int&, int> >::value, "");
59+
static_assert(!std::is_trivially_copyable<std::pair<int, int&> >::value, "");
60+
static_assert(!std::is_trivially_copyable<std::pair<int&, int&> >::value, "");
61+
62+
#ifdef _LIBCPP_ABI_TRIVIALLY_COPYABLE_PAIR
63+
static_assert(std::is_trivially_copyable<std::pair<int, int> >::value, "");
64+
static_assert(std::is_trivially_copyable<std::pair<int, char> >::value, "");
65+
static_assert(std::is_trivially_copyable<std::pair<char, int> >::value, "");
66+
static_assert(std::is_trivially_copyable<std::pair<std::pair<char, char>, int> >::value, "");
67+
static_assert(std::is_trivially_copyable<std::pair<trivially_copyable, int> >::value, "");
68+
static_assert(std::is_trivially_copyable<std::pair<trivially_copyable_no_assignment, int> >::value, "");
69+
static_assert(std::is_trivially_copyable<std::pair<trivially_copyable_no_construction, int> >::value, "");
70+
71+
static_assert(std::is_trivially_copy_constructible<std::pair<int, int> >::value, "");
72+
static_assert(std::is_trivially_move_constructible<std::pair<int, int> >::value, "");
73+
static_assert(std::is_trivially_copy_assignable<std::pair<int, int> >::value, "");
74+
static_assert(std::is_trivially_move_assignable<std::pair<int, int> >::value, "");
75+
static_assert(std::is_trivially_destructible<std::pair<int, int> >::value, "");
76+
77+
#else // _LIBCPP_ABI_TRIVIALLY_COPYABLE_PAIR
78+
static_assert(!std::is_trivially_copyable<std::pair<int, int> >::value, "");
79+
static_assert(!std::is_trivially_copyable<std::pair<int, char> >::value, "");
80+
static_assert(!std::is_trivially_copyable<std::pair<char, int> >::value, "");
81+
static_assert(!std::is_trivially_copyable<std::pair<std::pair<char, char>, int> >::value, "");
82+
static_assert(!std::is_trivially_copyable<std::pair<trivially_copyable, int> >::value, "");
83+
# if TEST_STD_VER >= 23
84+
static_assert(!std::is_trivially_copyable<std::pair<trivially_copyable_no_assignment, int> >::value, "");
85+
# else
86+
static_assert(std::is_trivially_copyable<std::pair<trivially_copyable_no_assignment, int> >::value, "");
87+
# endif
88+
static_assert(!std::is_trivially_copyable<std::pair<trivially_copyable_no_construction, int> >::value, "");
89+
90+
static_assert(std::is_trivially_copy_constructible<std::pair<int, int> >::value, "");
91+
static_assert(std::is_trivially_move_constructible<std::pair<int, int> >::value, "");
92+
static_assert(!std::is_trivially_copy_assignable<std::pair<int, int> >::value, "");
93+
static_assert(!std::is_trivially_move_assignable<std::pair<int, int> >::value, "");
94+
static_assert(std::is_trivially_destructible<std::pair<int, int> >::value, "");
95+
#endif // _LIBCPP_ABI_TRIVIALLY_COPYABLE_PAIR

0 commit comments

Comments
 (0)