This is an archive of the discontinued LLVM Phabricator instance.

Differential D91662

Revert switch-based std::variant implementation again.
ClosedPublic

Authored by EricWF on Nov 17 2020, 2:44 PM.

Details

Reviewers
ldionne
EricWF
Group Reviewers
Restricted Project
Summary

These changes cause substantial binary size increases for non-opt builds.
For example, the visit.pass.cpp test grows from 20k to 420k.

Further work will be done to re-land this patch without the size increases,
but that work is proving too tricky to fix forward.

This patch fully reverts:

* 35d226911165a9aae1f01f521a0019f1a9c0a25f

And it partially reverts:

* bb43a0cd4adc4f1fa12e0d2fd1fe9aa6b5c00e34

The latter of which added XFAIL's to new variant tests
because the new implementation needlessly makes non-throwing code
paths in variant invoke throwing code.

Diff Detail

Event Timeline

EricWF created this revision.Nov 17 2020, 2:44 PM
Herald added a reviewer: Restricted Project. · View Herald TranscriptNov 17 2020, 2:44 PM
Herald added a subscriber: libcxx-commits. · View Herald Transcript
EricWF requested review of this revision.Nov 17 2020, 2:44 PM
Harbormaster completed remote builds in B79188: Diff 305908.Nov 17 2020, 3:47 PM
EricWF updated this revision to Diff 305944.Nov 17 2020, 5:59 PM
EricWF edited the summary of this revision. (Show Details)

Revert the addition of unneeded availability XFAIL's to variant tests.

Herald added a subscriber: arphaman. · View Herald TranscriptNov 17 2020, 5:59 PM
EricWF accepted this revision as: Restricted Project.Nov 17 2020, 6:48 PM

I'm trying to trigger a rebuild. Does accepting as libc++ do it?

EricWF set the repository for this revision to rG LLVM Github Monorepo.Nov 17 2020, 6:57 PM
EricWF updated this revision to Diff 305955.Nov 17 2020, 7:00 PM

Attempting to trigger rebuild

Harbormaster completed remote builds in B79213: Diff 305955.Nov 17 2020, 8:00 PM
EricWF accepted this revision.Nov 17 2020, 8:06 PM

Bots are clean now.

The variant switch change also breaks backwards compatibility when targeting older OS X dylibs,
since it makes non-throwing relops and hash unavailable. We should fix that before recommitting things.

This revision is now accepted and ready to land.Nov 17 2020, 8:06 PM
EricWF mentioned this in rG9c09757bca58: [libc++] Revert switch-based std::variant implementation again..Nov 17 2020, 8:11 PM
ldionne closed this revision.Nov 20 2020, 1:04 PM

This was committed as 9c09757bca58a49d87f70584cff6f5bcb20f29b1.

scott.linder mentioned this in D98477: [ADT] Add IntrusiveVariant, VariantTraits, and new STLForwardCompat.May 19 2021, 9:10 AM

Revision Contents

PathSize
libcxx/
include/
357 lines
test/
std/
utilities/
variant/
variant.hash/
6 lines
variant.relops/
6 lines
6 lines
variant.variant/
variant.dtor/
6 lines
variant.status/
6 lines
6 lines

Diff 305955

libcxx/include/variant

Show First 20 Lines • Show All 349 Lines • ▼ Show 20 Lines
} // namespace __find_detail } // namespace __find_detail
namespace __variant_detail { namespace __variant_detail {
struct __valueless_t {}; struct __valueless_t {};
enum class _Trait { _TriviallyAvailable, _Available, _Unavailable }; enum class _Trait { _TriviallyAvailable, _Available, _Unavailable };
template <class _Tp, template <typename _Tp,
template <class> class _IsTriviallyAvailable, template <typename> class _IsTriviallyAvailable,
template <class> class _IsAvailable> template <typename> class _IsAvailable>
constexpr _Trait __trait = constexpr _Trait __trait =
_IsTriviallyAvailable<_Tp>::value _IsTriviallyAvailable<_Tp>::value
? _Trait::_TriviallyAvailable ? _Trait::_TriviallyAvailable
: _IsAvailable<_Tp>::value ? _Trait::_Available : _Trait::_Unavailable; : _IsAvailable<_Tp>::value ? _Trait::_Available : _Trait::_Unavailable;
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
constexpr _Trait __common_trait(initializer_list<_Trait> __traits) { constexpr _Trait __common_trait(initializer_list<_Trait> __traits) {
_Trait __result = _Trait::_TriviallyAvailable; _Trait __result = _Trait::_TriviallyAvailable;
for (_Trait __t : __traits) { for (_Trait __t : __traits) {
if (static_cast<int>(__t) > static_cast<int>(__result)) { if (static_cast<int>(__t) > static_cast<int>(__result)) {
__result = __t; __result = __t;
} }
} }
return __result; return __result;
} }
template <class... _Types> template <typename... _Types>
struct __traits { struct __traits {
static constexpr _Trait __copy_constructible_trait = static constexpr _Trait __copy_constructible_trait =
__common_trait({__trait<_Types, __common_trait({__trait<_Types,
is_trivially_copy_constructible, is_trivially_copy_constructible,
is_copy_constructible>...}); is_copy_constructible>...});
static constexpr _Trait __move_constructible_trait = static constexpr _Trait __move_constructible_trait =
__common_trait({__trait<_Types, __common_trait({__trait<_Types,
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines static constexpr auto&& __get_alt(_Vp&& __v) {
return __base::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v).__impl); return __base::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v).__impl);
} }
}; };
} // namespace __access } // namespace __access
namespace __visitation { namespace __visitation {
#define _LIBCPP_VARIANT_CASES_4(_Case, _Base) \ struct __base {
_Case(_Base + 0) \ template <class _Visitor, class... _Vs>
_Case(_Base + 1) \
_Case(_Base + 2) \
_Case(_Base + 3)
#define _LIBCPP_VARIANT_CASES_16(_Case, _Base) \
_LIBCPP_VARIANT_CASES_4(_Case, _Base + 4 * 0) \
_LIBCPP_VARIANT_CASES_4(_Case, _Base + 4 * 1) \
_LIBCPP_VARIANT_CASES_4(_Case, _Base + 4 * 2) \
_LIBCPP_VARIANT_CASES_4(_Case, _Base + 4 * 3)
#define _LIBCPP_VARIANT_CASES_64(_Case, _Base) \
_LIBCPP_VARIANT_CASES_16(_Case, _Base + 16 * 0) \
_LIBCPP_VARIANT_CASES_16(_Case, _Base + 16 * 1) \
_LIBCPP_VARIANT_CASES_16(_Case, _Base + 16 * 2) \
_LIBCPP_VARIANT_CASES_16(_Case, _Base + 16 * 3)
#define _LIBCPP_VARIANT_CASES_256(_Case, _Base) \
_LIBCPP_VARIANT_CASES_64(_Case, _Base + 64 * 0) \
_LIBCPP_VARIANT_CASES_64(_Case, _Base + 64 * 1) \
_LIBCPP_VARIANT_CASES_64(_Case, _Base + 64 * 2) \
_LIBCPP_VARIANT_CASES_64(_Case, _Base + 64 * 3)
#define _LIBCPP_VARIANT_CASES(_NumCases, _Case) \
_LIBCPP_CONCAT(_LIBCPP_VARIANT_CASES_, _NumCases)(_Case, 0)
#define _LIBCPP_VARIANT_SWITCH_MAX 256
template <class _Iter, class _Fp, size_t... _Is>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
static constexpr void __fill_cartesian_impl( static constexpr decltype(auto)
_Iter __iter, _Fp __f, index_sequence<_Is...>) { __visit_alt_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) {
*__iter = __f(integral_constant<size_t, _Is>{}...); constexpr auto __fdiagonal =
__make_fdiagonal<_Visitor&&,
decltype(_VSTD::forward<_Vs>(__vs).__as_base())...>();
return __fdiagonal[__index](_VSTD::forward<_Visitor>(__visitor),
_VSTD::forward<_Vs>(__vs).__as_base()...);
}
template <class _Visitor, class... _Vs>
inline _LIBCPP_INLINE_VISIBILITY
static constexpr decltype(auto) __visit_alt(_Visitor&& __visitor,
_Vs&&... __vs) {
constexpr auto __fmatrix =
__make_fmatrix<_Visitor&&,
decltype(_VSTD::forward<_Vs>(__vs).__as_base())...>();
return __at(__fmatrix, __vs.index()...)(
_VSTD::forward<_Visitor>(__visitor),
_VSTD::forward<_Vs>(__vs).__as_base()...);
} }
template <class _Iter, class _Fp, size_t... _Is, size_t... _Js, class... _Ls> private:
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
static constexpr void __fill_cartesian_impl( static constexpr const _Tp& __at(const _Tp& __elem) { return __elem; }
_Iter __iter, _Fp __f, index_sequence<_Is...>, index_sequence<_Js...>, _Ls... __ls) {
constexpr size_t _Mp = (1 * ... * _Ls::size());
(__fill_cartesian_impl(
__iter + _Js * _Mp, __f, index_sequence<_Is..., _Js>{}, __ls...), ...);
}
template <size_t... _Ns, class _Iter, class _Fp> template <class _Tp, size_t _Np, typename... _Indices>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
static constexpr void __fill_cartesian(_Iter __iter, _Fp __f) { static constexpr auto&& __at(const array<_Tp, _Np>& __elems,
__fill_cartesian_impl( size_t __index, _Indices... __indices) {
__iter, __f, index_sequence<>{}, make_index_sequence<_Ns>{}...); return __at(__elems[__index], __indices...);
} }
template <size_t _Np, size_t... _Ns> template <class _Fp, class... _Fs>
struct __multi { static constexpr void __std_visit_visitor_return_type_check() {
inline _LIBCPP_INLINE_VISIBILITY static_assert(
static constexpr size_t __size = (_Np * ... * _Ns); __all<is_same_v<_Fp, _Fs>...>::value,
"`std::visit` requires the visitor to have a single return type.");
}
template <class... _Fs>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
static constexpr size_t static constexpr auto __make_farray(_Fs&&... __fs) {
__index(const size_t (&__is)[sizeof...(_Ns) + 1]) noexcept { __std_visit_visitor_return_type_check<__uncvref_t<_Fs>...>();
constexpr size_t __ns[] = {_Ns..., 1}; using __result = array<common_type_t<__uncvref_t<_Fs>...>, sizeof...(_Fs)>;
size_t __result = 0; return __result{{_VSTD::forward<_Fs>(__fs)...}};
for (size_t __i = 0; __i < sizeof...(_Ns) + 1; ++__i) {
if (__is[__i] == variant_npos) {
return variant_npos;
}
__result += __is[__i];
__result *= __ns[__i];
}
return __result;
} }
};
template <size_t... _Ns> template <std::size_t... _Is>
struct __indices { struct __dispatcher {
template <class _Fp, class... _Vs>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
static constexpr auto __value = [] { static constexpr decltype(auto) __dispatch(_Fp __f, _Vs... __vs) {
using _Tp = array<size_t, sizeof...(_Ns)>; return __invoke_constexpr(
array<_Tp, (1 * ... * _Ns)> __result = {}; static_cast<_Fp>(__f),
__fill_cartesian<_Ns...>(__result.begin(), __access::__base::__get_alt<_Is>(static_cast<_Vs>(__vs))...);
[](auto... __is) -> _Tp { return {__is...}; }); }
return __result;
}();
}; };
template <size_t... _Ns, class _Fp, class _Rp, class... _Args> template <class _Fp, class... _Vs, size_t... _Is>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS inline _LIBCPP_INLINE_VISIBILITY
static constexpr auto __make_vtable_impl(_Fp __f, _Rp (*)(_Args...)) { static constexpr auto __make_dispatch(index_sequence<_Is...>) {
array<_Rp (*)(_Args...), (1 * ... * _Ns) + 1> __result = { return __dispatcher<_Is...>::template __dispatch<_Fp, _Vs...>;
[](_Args...) -> _Rp { __throw_bad_variant_access(); }
};
__fill_cartesian<_Ns...>(__result.begin() + 1, __f);
return __result;
} }
template <size_t... _Ns, class _Fp> template <size_t _Ip, class _Fp, class... _Vs>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
static constexpr auto __make_vtable(_Fp __f) { static constexpr auto __make_fdiagonal_impl() {
using _Tp = decltype(__f(integral_constant<size_t, (_Ns, 0)>{}...)); return __make_dispatch<_Fp, _Vs...>(
return __make_vtable_impl<_Ns...>(__f, _Tp{}); index_sequence<(__identity<_Vs>{}, _Ip)...>{});
} }
struct __base { template <class _Fp, class... _Vs, size_t... _Is>
template <class _Vis, class... _Vs>
struct __dispatch {
template <size_t... _Is>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
constexpr auto operator()(integral_constant<size_t, _Is>...) const noexcept { static constexpr auto __make_fdiagonal_impl(index_sequence<_Is...>) {
return +[](_Vis&& __vis, _Vs&&... __vs) -> decltype(auto) { return __base::__make_farray(__make_fdiagonal_impl<_Is, _Fp, _Vs...>()...);
return __invoke_constexpr(
_VSTD::forward<_Vis>(__vis),
__access::__base::__get_alt<_Is>(_VSTD::forward<_Vs>(__vs))...);
};
} }
};
template <class _Vis, class _Vp, class _Wp> template <class _Fp, class _Vp, class... _Vs>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS inline _LIBCPP_INLINE_VISIBILITY
static constexpr decltype(auto) static constexpr auto __make_fdiagonal() {
__visit_alt_at(size_t __index, _Vis&& __vis, _Vp&& __v, _Wp&& __w) { constexpr size_t _Np = __uncvref_t<_Vp>::__size();
constexpr size_t __size = __uncvref_t<_Vp>::__size(); static_assert(__all<(_Np == __uncvref_t<_Vs>::__size())...>::value);
static_assert(__size == __uncvref_t<_Wp>::__size()); return __make_fdiagonal_impl<_Fp, _Vp, _Vs...>(make_index_sequence<_Np>{});
constexpr auto __dispatch_at = [](auto __i) {
return __dispatch<_Vis, _Vp, _Wp>{}(__i, __i);
};
#define _LIBCPP_VARIANT_CASE(_Ip) \
case _Ip: { \
if constexpr (_Ip < __size) { \
return __dispatch_at(integral_constant<size_t, _Ip>{})( \
_VSTD::forward<_Vis>(__vis), \
_VSTD::forward<_Vp>(__v), \
_VSTD::forward<_Wp>(__w)); \
} else { \
_LIBCPP_UNREACHABLE(); \
} \
}
if constexpr (__size <= _LIBCPP_VARIANT_SWITCH_MAX) {
switch (__index) {
_LIBCPP_VARIANT_CASES(_LIBCPP_VARIANT_SWITCH_MAX, _LIBCPP_VARIANT_CASE)
default: __throw_bad_variant_access();
}
} else {
constexpr auto __vtable = __make_vtable<__size>(__dispatch_at);
return __vtable[__index + 1](_VSTD::forward<_Vis>(__vis),
_VSTD::forward<_Vp>(__v),
_VSTD::forward<_Wp>(__w));
}
#undef _LIBCPP_VARIANT_CASE
} }
template <size_t... _Is, class _Vis, class... _Vs> template <class _Fp, class... _Vs, size_t... _Is>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
static constexpr decltype(auto) __visit_alt(_Vis&& __vis, _Vs&&... __vs) { static constexpr auto __make_fmatrix_impl(index_sequence<_Is...> __is) {
if constexpr (sizeof...(_Vs) == 0) { return __make_dispatch<_Fp, _Vs...>(__is);
return __invoke_constexpr(_VSTD::forward<_Vis>(__vis));
} else {
return __visit_alt_impl(index_sequence_for<_Vs...>{},
_VSTD::forward<_Vis>(__vis),
_VSTD::forward<_Vs>(__vs)...);
}
} }
template <size_t... _Is, class _Vis, class... _Vs> template <class _Fp, class... _Vs, size_t... _Is, size_t... _Js, class... _Ls>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS inline _LIBCPP_INLINE_VISIBILITY
static constexpr decltype(auto) static constexpr auto __make_fmatrix_impl(index_sequence<_Is...>,
__visit_alt_impl(index_sequence<_Is...>, _Vis&& __vis, _Vs&&... __vs) { index_sequence<_Js...>,
using __multi = __multi<__uncvref_t<_Vs>::__size()...>; _Ls... __ls) {
constexpr __dispatch<_Vis, _Vs...> __dispatch; return __base::__make_farray(__make_fmatrix_impl<_Fp, _Vs...>(
#define _LIBCPP_VARIANT_CASE(_Ip) \ index_sequence<_Is..., _Js>{}, __ls...)...);
case _Ip: { \
if constexpr (_Ip < __multi::__size) { \
return __dispatch(integral_constant<size_t, __itable[_Ip][_Is]>{}...)( \
_VSTD::forward<_Vis>(__vis), _VSTD::forward<_Vs>(__vs)...); \
} else { \
_LIBCPP_UNREACHABLE(); \
} \
}
if constexpr (__multi::__size <= _LIBCPP_VARIANT_SWITCH_MAX) {
constexpr const auto& __itable =
__indices<__uncvref_t<_Vs>::__size()...>::__value;
switch (__multi::__index({__vs.index()...})) {
_LIBCPP_VARIANT_CASES(_LIBCPP_VARIANT_SWITCH_MAX, _LIBCPP_VARIANT_CASE)
default: __throw_bad_variant_access();
}
} else {
constexpr auto __vtable =
__make_vtable<__uncvref_t<_Vs>::__size()...>(__dispatch);
return __vtable[__multi::__index({__vs.index()...}) + 1](
_VSTD::forward<_Vis>(__vis), _VSTD::forward<_Vs>(__vs)...);
} }
#undef _LIBCPP_VARIANT_CASE
template <class _Fp, class... _Vs>
inline _LIBCPP_INLINE_VISIBILITY
static constexpr auto __make_fmatrix() {
return __make_fmatrix_impl<_Fp, _Vs...>(
index_sequence<>{}, make_index_sequence<__uncvref_t<_Vs>::__size()>{}...);
} }
}; };
struct __variant { struct __variant {
template <class _Vis, class _Vp, class _Wp> template <class _Visitor, class... _Vs>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
static constexpr decltype(auto) static constexpr decltype(auto)
__visit_alt_at(size_t __index, _Vis&& __vis, _Vp&& __v, _Wp&& __w) { __visit_alt_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) {
return __base::__visit_alt_at(__index, return __base::__visit_alt_at(__index,
_VSTD::forward<_Vis>(__vis), _VSTD::forward<_Visitor>(__visitor),
_VSTD::forward<_Vp>(__v).__impl, _VSTD::forward<_Vs>(__vs).__impl...);
_VSTD::forward<_Wp>(__w).__impl);
} }
template <class _Vis, class... _Vs> template <class _Visitor, class... _Vs>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
static constexpr decltype(auto) __visit_alt(_Vis&& __vis, _Vs&&... __vs) { static constexpr decltype(auto) __visit_alt(_Visitor&& __visitor,
return __base::__visit_alt(_VSTD::forward<_Vis>(__vis), _Vs&&... __vs) {
return __base::__visit_alt(_VSTD::forward<_Visitor>(__visitor),
_VSTD::forward<_Vs>(__vs).__impl...); _VSTD::forward<_Vs>(__vs).__impl...);
} }
template <class _Vis, class _Vp, class _Wp> template <class _Visitor, class... _Vs>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
static constexpr decltype(auto) static constexpr decltype(auto)
__visit_value_at(size_t __index, _Vis&& __vis, _Vp&& __v, _Wp&& __w) { __visit_value_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) {
return __visit_alt_at(__index, return __visit_alt_at(
__make_value_visitor(_VSTD::forward<_Vis>(__vis)), __index,
_VSTD::forward<_Vp>(__v), __make_value_visitor(_VSTD::forward<_Visitor>(__visitor)),
_VSTD::forward<_Wp>(__w)); _VSTD::forward<_Vs>(__vs)...);
} }
template <class _Vis, class... _Vs> template <class _Visitor, class... _Vs>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
static constexpr decltype(auto) __visit_value(_Vis&& __vis, _Vs&&... __vs) { static constexpr decltype(auto) __visit_value(_Visitor&& __visitor,
return __visit_alt(__make_value_visitor(_VSTD::forward<_Vis>(__vis)), _Vs&&... __vs) {
return __visit_alt(
__make_value_visitor(_VSTD::forward<_Visitor>(__visitor)),
_VSTD::forward<_Vs>(__vs)...); _VSTD::forward<_Vs>(__vs)...);
} }
private: private:
template <class _Vis, class... _Values> template <class _Visitor, class... _Values>
inline _LIBCPP_INLINE_VISIBILITY
static constexpr void __std_visit_exhaustive_visitor_check() { static constexpr void __std_visit_exhaustive_visitor_check() {
static_assert(is_invocable_v<_Vis, _Values...>, static_assert(is_invocable_v<_Visitor, _Values...>,
"`std::visit` requires the visitor to be exhaustive."); "`std::visit` requires the visitor to be exhaustive.");
} }
template <class _Vis> template <class _Visitor>
struct __value_visitor { struct __value_visitor {
template <class... _Alts> template <class... _Alts>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
constexpr decltype(auto) operator()(_Alts&&... __alts) const { constexpr decltype(auto) operator()(_Alts&&... __alts) const {
__std_visit_exhaustive_visitor_check< __std_visit_exhaustive_visitor_check<
_Vis, decltype((_VSTD::forward<_Alts>(__alts).__value))...>(); _Visitor,
return __invoke_constexpr(_VSTD::forward<_Vis>(__vis), decltype((_VSTD::forward<_Alts>(__alts).__value))...>();
return __invoke_constexpr(_VSTD::forward<_Visitor>(__visitor),
_VSTD::forward<_Alts>(__alts).__value...); _VSTD::forward<_Alts>(__alts).__value...);
} }
_Vis&& __vis; _Visitor&& __visitor;
}; };
template <class _Vis> template <class _Visitor>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
static constexpr auto __make_value_visitor(_Vis&& __vis) { static constexpr auto __make_value_visitor(_Visitor&& __visitor) {
return __value_visitor<_Vis>{_VSTD::forward<_Vis>(__vis)}; return __value_visitor<_Visitor>{_VSTD::forward<_Visitor>(__visitor)};
} }
}; };
#undef _LIBCPP_VARIANT_SWITCH_MAX
#undef _LIBCPP_VARIANT_CASES
#undef _LIBCPP_VARIANT_CASES_256
#undef _LIBCPP_VARIANT_CASES_64
#undef _LIBCPP_VARIANT_CASES_16
#undef _LIBCPP_VARIANT_CASES_4
} // namespace __visitation } // namespace __visitation
template <size_t _Index, class _Tp> template <size_t _Index, class _Tp>
struct _LIBCPP_TEMPLATE_VIS __alt { struct _LIBCPP_TEMPLATE_VIS __alt {
using __value_type = _Tp; using __value_type = _Tp;
template <class... _Args> template <class... _Args>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
explicit constexpr __alt(in_place_t, _Args&&... __args) explicit constexpr __alt(in_place_t, _Args&&... __args)
: __value(_VSTD::forward<_Args>(__args)...) {} : __value(_VSTD::forward<_Args>(__args)...) {}
__value_type __value; __value_type __value;
}; };
template <_Trait _DestructibleTrait, size_t _Index, class... _Types> template <_Trait _DestructibleTrait, size_t _Index, class... _Types>
union _LIBCPP_TEMPLATE_VIS __union; union _LIBCPP_TEMPLATE_VIS __union;
template <_Trait _DestructibleTrait, size_t _Index> template <_Trait _DestructibleTrait, size_t _Index>
union _LIBCPP_TEMPLATE_VIS __union<_DestructibleTrait, _Index> {}; union _LIBCPP_TEMPLATE_VIS __union<_DestructibleTrait, _Index> {};
#define _LIBCPP_VARIANT_UNION(destructible_trait, destructor) \ #define _LIBCPP_VARIANT_UNION(destructible_trait, destructor) \
template <size_t _Index, class _Tp, class... _Types> \ template <size_t _Index, class _Tp, class... _Types> \
union _LIBCPP_TEMPLATE_VIS __union<destructible_trait, \ union _LIBCPP_TEMPLATE_VIS __union<destructible_trait, \
_Index, \ _Index, \
_Tp, \ _Tp, \
_Types...> { \ _Types...> { \
public: \ public: \
inline _LIBCPP_INLINE_VISIBILITY \ inline _LIBCPP_INLINE_VISIBILITY \
explicit constexpr __union(__valueless_t) noexcept : __dummy{} {} \ explicit constexpr __union(__valueless_t) noexcept : __dummy{} {} \
\ \
template <class... _Args> \ template <class... _Args> \
▲ Show 20 Lines • Show All 137 Lines • ▼ Show 20 Lines
public: public:
using __base_type::__base_type; using __base_type::__base_type;
using __base_type::operator=; using __base_type::operator=;
protected: protected:
template <size_t _Ip, class _Tp, class... _Args> template <size_t _Ip, class _Tp, class... _Args>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
static _Tp& __construct_alt(__alt<_Ip, _Tp>& __a, _Args&&... __args) { static _Tp& __construct_alt(__alt<_Ip, _Tp>& __a, _Args&&... __args) {
auto* __result = ::new ((void*)_VSTD::addressof(__a)) ::new ((void*)_VSTD::addressof(__a))
__alt<_Ip, _Tp>(in_place, _VSTD::forward<_Args>(__args)...); __alt<_Ip, _Tp>(in_place, _VSTD::forward<_Args>(__args)...);
return __result->__value; return __a.__value;
} }
template <class _Rhs> template <class _Rhs>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
static void __generic_construct(__ctor& __lhs, _Rhs&& __rhs) { static void __generic_construct(__ctor& __lhs, _Rhs&& __rhs) {
__lhs.__destroy(); __lhs.__destroy();
if (!__rhs.valueless_by_exception()) { if (!__rhs.valueless_by_exception()) {
__visitation::__base::__visit_alt_at( __visitation::__base::__visit_alt_at(
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
#undef _LIBCPP_VARIANT_MOVE_CONSTRUCTOR #undef _LIBCPP_VARIANT_MOVE_CONSTRUCTOR
template <class _Traits, _Trait = _Traits::__copy_constructible_trait> template <class _Traits, _Trait = _Traits::__copy_constructible_trait>
class _LIBCPP_TEMPLATE_VIS __copy_constructor; class _LIBCPP_TEMPLATE_VIS __copy_constructor;
#define _LIBCPP_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait, \ #define _LIBCPP_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait, \
copy_constructor) \ copy_constructor) \
template <class... _Types> \ template <class... _Types> \
class _LIBCPP_TEMPLATE_VIS __copy_constructor<__traits<_Types...>, \ class _LIBCPP_TEMPLATE_VIS __copy_constructor<__traits<_Types...>, \
copy_constructible_trait> \ copy_constructible_trait> \
: public __move_constructor<__traits<_Types...>> { \ : public __move_constructor<__traits<_Types...>> { \
using __base_type = __move_constructor<__traits<_Types...>>; \ using __base_type = __move_constructor<__traits<_Types...>>; \
\ \
public: \ public: \
using __base_type::__base_type; \ using __base_type::__base_type; \
using __base_type::operator=; \ using __base_type::operator=; \
\ \
Show All 29 Linespublic:
using __base_type::__base_type; using __base_type::__base_type;
using __base_type::operator=; using __base_type::operator=;
template <size_t _Ip, class... _Args> template <size_t _Ip, class... _Args>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
auto& __emplace(_Args&&... __args) { auto& __emplace(_Args&&... __args) {
this->__destroy(); this->__destroy();
auto& __res = this->__construct_alt(__access::__base::__get_alt<_Ip>(*this), auto& __res = this->__construct_alt(__access::__base::__get_alt<_Ip>(*this),
_VSTD::forward<_Args>(__args)...); _VSTD::forward<_Args>(__args)...);
this->__index = _Ip; this->__index = _Ip;
return __res; return __res;
} }
protected: protected:
template <size_t _Ip, class _Tp, class _Arg> template <size_t _Ip, class _Tp, class _Arg>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
void __assign_alt(__alt<_Ip, _Tp>& __a, _Arg&& __arg) { void __assign_alt(__alt<_Ip, _Tp>& __a, _Arg&& __arg) {
Show All 36 Lines
}; };
template <class _Traits, _Trait = _Traits::__move_assignable_trait> template <class _Traits, _Trait = _Traits::__move_assignable_trait>
class _LIBCPP_TEMPLATE_VIS __move_assignment; class _LIBCPP_TEMPLATE_VIS __move_assignment;
#define _LIBCPP_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait, \ #define _LIBCPP_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait, \
move_assignment) \ move_assignment) \
template <class... _Types> \ template <class... _Types> \
class _LIBCPP_TEMPLATE_VIS __move_assignment<__traits<_Types...>, \ class _LIBCPP_TEMPLATE_VIS __move_assignment<__traits<_Types...>, \
move_assignable_trait> \ move_assignable_trait> \
: public __assignment<__traits<_Types...>> { \ : public __assignment<__traits<_Types...>> { \
using __base_type = __assignment<__traits<_Types...>>; \ using __base_type = __assignment<__traits<_Types...>>; \
\ \
public: \ public: \
using __base_type::__base_type; \ using __base_type::__base_type; \
using __base_type::operator=; \ using __base_type::operator=; \
\ \
Show All 24 Lines
#undef _LIBCPP_VARIANT_MOVE_ASSIGNMENT #undef _LIBCPP_VARIANT_MOVE_ASSIGNMENT
template <class _Traits, _Trait = _Traits::__copy_assignable_trait> template <class _Traits, _Trait = _Traits::__copy_assignable_trait>
class _LIBCPP_TEMPLATE_VIS __copy_assignment; class _LIBCPP_TEMPLATE_VIS __copy_assignment;
#define _LIBCPP_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait, \ #define _LIBCPP_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait, \
copy_assignment) \ copy_assignment) \
template <class... _Types> \ template <class... _Types> \
class _LIBCPP_TEMPLATE_VIS __copy_assignment<__traits<_Types...>, \ class _LIBCPP_TEMPLATE_VIS __copy_assignment<__traits<_Types...>, \
copy_assignable_trait> \ copy_assignable_trait> \
: public __move_assignment<__traits<_Types...>> { \ : public __move_assignment<__traits<_Types...>> { \
using __base_type = __move_assignment<__traits<_Types...>>; \ using __base_type = __move_assignment<__traits<_Types...>>; \
\ \
public: \ public: \
using __base_type::__base_type; \ using __base_type::__base_type; \
using __base_type::operator=; \ using __base_type::operator=; \
\ \
▲ Show 20 Lines • Show All 577 Lines • ▼ Show 20 Linesconstexpr bool operator>=(const variant<_Types...>& __lhs,
if (__rhs.valueless_by_exception()) return true; if (__rhs.valueless_by_exception()) return true;
if (__lhs.valueless_by_exception()) return false; if (__lhs.valueless_by_exception()) return false;
if (__lhs.index() > __rhs.index()) return true; if (__lhs.index() > __rhs.index()) return true;
if (__lhs.index() < __rhs.index()) return false; if (__lhs.index() < __rhs.index()) return false;
return __variant::__visit_value_at( return __variant::__visit_value_at(
__lhs.index(), __convert_to_bool<greater_equal<>>{}, __lhs, __rhs); __lhs.index(), __convert_to_bool<greater_equal<>>{}, __lhs, __rhs);
} }
template <class _Vis, class... _Vs> template <class _Visitor, class... _Vs>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
constexpr decltype(auto) visit(_Vis&& __vis, _Vs&&... __vs) { constexpr decltype(auto) visit(_Visitor&& __visitor, _Vs&&... __vs) {
using __variant_detail::__visitation::__variant; using __variant_detail::__visitation::__variant;
return __variant::__visit_value(_VSTD::forward<_Vis>(__vis), bool __results[] = {__vs.valueless_by_exception()...};
for (bool __result : __results) {
if (__result) {
__throw_bad_variant_access();
}
}
return __variant::__visit_value(_VSTD::forward<_Visitor>(__visitor),
_VSTD::forward<_Vs>(__vs)...); _VSTD::forward<_Vs>(__vs)...);
} }
struct _LIBCPP_TEMPLATE_VIS monostate {}; struct _LIBCPP_TEMPLATE_VIS monostate {};
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
constexpr bool operator<(monostate, monostate) noexcept { return false; } constexpr bool operator<(monostate, monostate) noexcept { return false; }
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/test/std/utilities/variant/variant.hash/hash.pass.cpp

// -*- C++ -*- // -*- C++ -*-
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// Throwing bad_variant_access is supported starting in macosx10.13
// XFAIL: with_system_cxx_lib=macosx10.12 && !no-exceptions
// XFAIL: with_system_cxx_lib=macosx10.11 && !no-exceptions
// XFAIL: with_system_cxx_lib=macosx10.10 && !no-exceptions
// XFAIL: with_system_cxx_lib=macosx10.9 && !no-exceptions
// <variant> // <variant>
// template <class... Types> struct hash<variant<Types...>>; // template <class... Types> struct hash<variant<Types...>>;
// template <> struct hash<monostate>; // template <> struct hash<monostate>;
#include <cassert> #include <cassert>
#include <type_traits> #include <type_traits>
#include <variant> #include <variant>
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

libcxx/test/std/utilities/variant/variant.relops/relops.pass.cpp

// -*- C++ -*- // -*- C++ -*-
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// Throwing bad_variant_access is supported starting in macosx10.13
// XFAIL: with_system_cxx_lib=macosx10.12 && !no-exceptions
// XFAIL: with_system_cxx_lib=macosx10.11 && !no-exceptions
// XFAIL: with_system_cxx_lib=macosx10.10 && !no-exceptions
// XFAIL: with_system_cxx_lib=macosx10.9 && !no-exceptions
// <variant> // <variant>
// template <class ...Types> // template <class ...Types>
// constexpr bool // constexpr bool
// operator==(variant<Types...> const&, variant<Types...> const&) noexcept; // operator==(variant<Types...> const&, variant<Types...> const&) noexcept;
// //
// template <class ...Types> // template <class ...Types>
// constexpr bool // constexpr bool
▲ Show 20 Lines • Show All 258 Lines • Show Last 20 Lines

libcxx/test/std/utilities/variant/variant.relops/relops_bool_conv.fail.cpp

// -*- C++ -*- // -*- C++ -*-
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// Throwing bad_variant_access is supported starting in macosx10.13
// XFAIL: with_system_cxx_lib=macosx10.12 && !no-exceptions
// XFAIL: with_system_cxx_lib=macosx10.11 && !no-exceptions
// XFAIL: with_system_cxx_lib=macosx10.10 && !no-exceptions
// XFAIL: with_system_cxx_lib=macosx10.9 && !no-exceptions
// <variant> // <variant>
// template <class ...Types> // template <class ...Types>
// constexpr bool // constexpr bool
// operator==(variant<Types...> const&, variant<Types...> const&) noexcept; // operator==(variant<Types...> const&, variant<Types...> const&) noexcept;
// //
// template <class ...Types> // template <class ...Types>
// constexpr bool // constexpr bool
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

libcxx/test/std/utilities/variant/variant.variant/variant.dtor/dtor.pass.cpp

// -*- C++ -*- // -*- C++ -*-
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// Throwing bad_variant_access is supported starting in macosx10.13
// XFAIL: with_system_cxx_lib=macosx10.12 && !no-exceptions
// XFAIL: with_system_cxx_lib=macosx10.11 && !no-exceptions
// XFAIL: with_system_cxx_lib=macosx10.10 && !no-exceptions
// XFAIL: with_system_cxx_lib=macosx10.9 && !no-exceptions
// <variant> // <variant>
// template <class ...Types> class variant; // template <class ...Types> class variant;
// ~variant(); // ~variant();
#include <cassert> #include <cassert>
#include <type_traits> #include <type_traits>
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

libcxx/test/std/utilities/variant/variant.variant/variant.status/index.pass.cpp

// -*- C++ -*- // -*- C++ -*-
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// Throwing bad_variant_access is supported starting in macosx10.13
// XFAIL: with_system_cxx_lib=macosx10.12 && !no-exceptions
// XFAIL: with_system_cxx_lib=macosx10.11 && !no-exceptions
// XFAIL: with_system_cxx_lib=macosx10.10 && !no-exceptions
// XFAIL: with_system_cxx_lib=macosx10.9 && !no-exceptions
// <variant> // <variant>
// template <class ...Types> class variant; // template <class ...Types> class variant;
// constexpr size_t index() const noexcept; // constexpr size_t index() const noexcept;
#include <cassert> #include <cassert>
#include <string> #include <string>
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libcxx/test/std/utilities/variant/variant.variant/variant.status/valueless_by_exception.pass.cpp

// -*- C++ -*- // -*- C++ -*-
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// Throwing bad_variant_access is supported starting in macosx10.13
// XFAIL: with_system_cxx_lib=macosx10.12 && !no-exceptions
// XFAIL: with_system_cxx_lib=macosx10.11 && !no-exceptions
// XFAIL: with_system_cxx_lib=macosx10.10 && !no-exceptions
// XFAIL: with_system_cxx_lib=macosx10.9 && !no-exceptions
// <variant> // <variant>
// template <class ...Types> class variant; // template <class ...Types> class variant;
// constexpr bool valueless_by_exception() const noexcept; // constexpr bool valueless_by_exception() const noexcept;
#include <cassert> #include <cassert>
#include <string> #include <string>
Show All 36 Lines