This repository was archived by the owner on Mar 21, 2024. It is now read-only.

NVIDIA/libcudacxxPublic archive

NotificationsYou must be signed in to change notification settings
Fork191
Star2.3k

Commit070697d

authored

Fix most libcxx tests (#471)

* Use `__libcpp_is_unsigned_integer` for `<bit>`* Do not use compiler builtin in tuple swap signature* Do not try CTAD with ancient gcc* Do not test constexpr `std::allocator` as that is not implemented* Add missing `__pragma_pop` to `<optional>`* Disable flaky threading tests for libcxx* Fix `optional` libcxx tests* Fix issues with our `construct_at` performance optimization* Disable complex edge case test for clangThe tests runs into constexpr evaluation limits* Disable modules tests for clang 9 and 10* Disable invalid test where where clang has been fixed

1 parent0adfef5 commit070697dCopy full SHA for 070697d

File tree

73 files changed

+250

-105

lines changed

include/cuda/std/detail/libcxx/include
- __memory
  - construct_at.h
- bit
- optional
- tuple
libcxx/test
- libcxx
  - modules
  - thread/thread.threads/thread.thread.this
    - sleep_for.pass.cpp
- std
  - numerics/complex.number/complex.ops
    - complex_divide_complex.pass.cpp
    - complex_times_complex.pass.cpp
  - thread
    - futures
      - futures.async
        async.pass.cpp
      - futures.shared_future
        wait_for.pass.cpp
        wait_until.pass.cpp
      - futures.unique_future
        wait_for.pass.cpp
    - thread.condition
      - thread.condition.condvarany
        notify_all.pass.cpp
        notify_one.pass.cpp
        wait_for.pass.cpp
        wait_for_pred.pass.cpp
        wait_until.pass.cpp
        wait_until_pred.pass.cpp
      - thread.condition.condvar
        notify_all.pass.cpp
        notify_one.pass.cpp
        wait_for.pass.cpp
        wait_for_pred.pass.cpp
        wait_until.pass.cpp
        wait_until_pred.pass.cpp
    - thread.mutex
      - thread.lock
        thread.lock.guard
        adopt_lock.pass.cpp
        mutex.pass.cpp
        thread.lock.shared
        thread.lock.shared.cons
        mutex.pass.cpp
        mutex_duration.pass.cpp
        mutex_time_point.pass.cpp
        mutex_try_to_lock.pass.cpp
        thread.lock.shared.locking
        lock.pass.cpp
        thread.lock.unique
        thread.lock.unique.cons
        mutex.pass.cpp
        mutex_duration.pass.cpp
        mutex_time_point.pass.cpp
        mutex_try_to_lock.pass.cpp
        thread.lock.unique.locking
        lock.pass.cpp
      - thread.mutex.requirements
        thread.mutex.requirements.mutex
        thread.mutex.class
        lock.pass.cpp
        try_lock.pass.cpp
        thread.mutex.recursive
        lock.pass.cpp
        try_lock.pass.cpp
        thread.shared_mutex.requirements/thread.shared_mutex.class
        lock.pass.cpp
        lock_shared.pass.cpp
        try_lock.pass.cpp
        try_lock_shared.pass.cpp
        thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class
        lock.pass.cpp
        lock_shared.pass.cpp
        try_lock.pass.cpp
        try_lock_for.pass.cpp
        try_lock_shared.pass.cpp
        try_lock_shared_for.pass.cpp
        try_lock_shared_until.pass.cpp
        try_lock_until.pass.cpp
        thread.timedmutex.requirements
        thread.timedmutex.class
        lock.pass.cpp
        try_lock.pass.cpp
        try_lock_for.pass.cpp
        try_lock_until.pass.cpp
        thread.timedmutex.recursive
        lock.pass.cpp
        try_lock.pass.cpp
        try_lock_for.pass.cpp
        try_lock_until.pass.cpp
    - thread.threads/thread.thread.this
      - sleep_until.pass.cpp
  - utilities
    - function.objects/refwrap/refwrap.const
      - type_conv_ctor.pass.cpp
    - memory/specialized.algorithms/specialized.construct
      - construct_at.pass.cpp
    - meta/meta.unary/meta.unary.prop
      - is_constructible.pass.cpp
    - optional
      - optional.object
        optional.object.assign
        optional_U.pass.cpp
        optional.object.ctor
        ctor.fail.cpp
        deduct.pass.cpp
        optional_requires_destructible_object.fail.cpp
      - optional.syn
        optional_nullopt_t.fail.cpp

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

73 files changed

+250

-105

lines changed

`‎include/cuda/std/detail/libcxx/include/__memory/construct_at.h‎`

Lines changed: 15 additions & 5 deletions

Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,9 @@ _LIBCUDACXX_BEGIN_NAMESPACE_STD`
`62`	`62`	`_LIBCUDACXX_DISABLE_EXEC_CHECK`
`63`	`63`	`template<class_Tp,class... _Args,class =decltype(::new(_CUDA_VSTD::declval<void*>()) _Tp(_CUDA_VSTD::declval<_Args>()...))>`
`64`	`64`	`_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17`
`65`		`-__enable_if_t<!is_trivially_constructible_v<_Tp, _Args...> \|\| !is_trivially_move_assignable_v<_Tp>, _Tp>construct_at(_Tp __location, _Args&&... __args) {`
	`65`	`+__enable_if_t<!is_trivially_constructible_v<_Tp, _Args...> \|\|`
	`66`	`+ !is_trivially_move_assignable_v<_Tp>, _Tp*>`
	`67`	`+construct_at(_Tp* __location, _Args&&... __args) {`
`66`	`68`	`_LIBCUDACXX_ASSERT(__location !=nullptr,"null pointer given to construct_at");`
`67`	`69`	`#if defined(__cuda_std__)`
`68`	`70`	// Need to go through `std::construct_at` as that is the explicitly blessed function
`@@ -76,24 +78,31 @@ __enable_if_t<!is_trivially_constructible_v<_Tp, _Args...> \|\| !is_trivially_move`
`76`	`78`	`_LIBCUDACXX_DISABLE_EXEC_CHECK`
`77`	`79`	`template<class_Tp,class... _Args,class =decltype(::new(_CUDA_VSTD::declval<void*>()) _Tp(_CUDA_VSTD::declval<_Args>()...))>`
`78`	`80`	`_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17`
`79`		`-__enable_if_t<is_trivially_constructible_v<_Tp, _Args...> && is_trivially_move_assignable_v<_Tp>, _Tp>construct_at(_Tp __location, _Args&&... __args) {`
	`81`	`+__enable_if_t<is_trivially_constructible_v<_Tp, _Args...> &&`
	`82`	`+ is_trivially_move_assignable_v<_Tp>, _Tp*>`
	`83`	`+construct_at(_Tp* __location, _Args&&... __args) {`
`80`	`84`	`_LIBCUDACXX_ASSERT(__location !=nullptr,"null pointer given to construct_at");`
`81`	`85`	`#if defined(__cuda_std__)`
`82`	`86`	// Need to go through `std::construct_at` as that is the explicitly blessed function
`83`	`87`	`if (__libcpp_is_constant_evaluated()) {`
`84`	`88`	`return ::std::construct_at(__location, _CUDA_VSTD::forward<_Args>(__args)...);`
`85`	`89`	`}`
`86`		`-#endif// __cuda_std__`
`87`	`90`	`*__location = _Tp{_CUDA_VSTD::forward<_Args>(__args)...};`
`88`	`91`	`return __location;`
	`92`	`+#else// ^^^ __cuda_std__ ^^^ / vvv !__cuda_std__ vvv`
	`93`	`+// NVCC always considers construction + move assignment, other compilers are smarter using copy construction`
	`94`	`+// So rather than adding all kinds of workarounds simply fall back to the correct implementation for libcxx mode`
	`95`	`+return ::new (_CUDA_VSTD::__voidify(*__location))_Tp(_CUDA_VSTD::forward<_Args>(__args)...);`
	`96`	`+#endif// !__cuda_std__`
`89`	`97`	`}`
`90`	`98`
`91`	`99`	`#endif// _LIBCUDACXX_STD_VER > 17`
`92`	`100`
`93`	`101`	`_LIBCUDACXX_DISABLE_EXEC_CHECK`
`94`	`102`	`template<class_Tp,class... _Args,class =decltype(::new(_CUDA_VSTD::declval<void*>()) _Tp(_CUDA_VSTD::declval<_Args>()...))>`
`95`	`103`	`_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17`
`96`		`-__enable_if_t<!_LIBCUDACXX_TRAIT(is_trivially_constructible, _Tp, _Args...) \|\| !_LIBCUDACXX_TRAIT(is_trivially_move_assignable, _Tp), _Tp>__construct_at(_Tp __location, _Args&&... __args) {`
	`104`	`+__enable_if_t<!_LIBCUDACXX_TRAIT(is_trivially_constructible, _Tp, _Args...) \|\| !_LIBCUDACXX_TRAIT(is_trivially_move_assignable, _Tp), _Tp*>`
	`105`	`+__construct_at(_Tp* __location, _Args&&... __args) {`
`97`	`106`	`_LIBCUDACXX_ASSERT(__location !=nullptr,"null pointer given to construct_at");`
`98`	`107`	`#if defined(__cuda_std__) && _LIBCUDACXX_STD_VER > 17`
`99`	`108`	// Need to go through `std::construct_at` as that is the explicitly blessed function
`@@ -107,7 +116,8 @@ __enable_if_t<!_LIBCUDACXX_TRAIT(is_trivially_constructible, _Tp, _Args...) \|\| !`
`107`	`116`	`_LIBCUDACXX_DISABLE_EXEC_CHECK`
`108`	`117`	`template<class_Tp,class... _Args,class =decltype(::new(_CUDA_VSTD::declval<void*>()) _Tp(_CUDA_VSTD::declval<_Args>()...))>`
`109`	`118`	`_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17`
`110`		`-__enable_if_t<_LIBCUDACXX_TRAIT(is_trivially_constructible, _Tp, _Args...) && _LIBCUDACXX_TRAIT(is_trivially_move_assignable, _Tp), _Tp>__construct_at(_Tp __location, _Args&&... __args) {`
	`119`	`+__enable_if_t<_LIBCUDACXX_TRAIT(is_trivially_constructible, _Tp, _Args...) && _LIBCUDACXX_TRAIT(is_trivially_move_assignable, _Tp), _Tp*>`
	`120`	`+__construct_at(_Tp* __location, _Args&&... __args) {`
`111`	`121`	`_LIBCUDACXX_ASSERT(__location !=nullptr,"null pointer given to construct_at");`
`112`	`122`	`#if defined(__cuda_std__) && _LIBCUDACXX_STD_VER > 17`
`113`	`123`	// Need to go through `std::construct_at` as that is the explicitly blessed function

`‎include/cuda/std/detail/libcxx/include/bit‎`

Lines changed: 20 additions & 32 deletions

Original file line number	Diff line number	Diff line change
`@@ -459,23 +459,11 @@ constexpr int __libcpp_popcount(unsigned long long __x) {`
`459`	`459`
`460`	`460`	`#endif// _LIBCUDACXX_COMPILER_MSVC`
`461`	`461`
`462`		`-template<class_Tp>`
`463`		`-using __bitop_unsigned_integer _LIBCUDACXX_NODEBUG_TYPE = integral_constant<bool,`
`464`		`- is_integral<_Tp>::value &&`
`465`		`- is_unsigned<_Tp>::value &&`
`466`		`- _IsNotSame<__remove_cv_t<_Tp>,bool>::value &&`
`467`		`- _IsNotSame<__remove_cv_t<_Tp>,signedchar>::value &&`
`468`		`- _IsNotSame<__remove_cv_t<_Tp>,wchar_t>::value &&`
`469`		`- _IsNotSame<__remove_cv_t<_Tp>,char16_t>::value &&`
`470`		`- _IsNotSame<__remove_cv_t<_Tp>,char32_t>::value`
`471`		`- >;`
`472`		`-`
`473`		`-`
`474`	`462`	`template<class_Tp>`
`475`	`463`	`_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_BIT_CONSTEXPR`
`476`	`464`	`_Tp__rotl(_Tp__t,unsignedint __cnt) _NOEXCEPT`
`477`	`465`	`{`
`478`		`-static_assert(__bitop_unsigned_integer<_Tp>::value,"__rotl requires unsigned");`
	`466`	`+static_assert(__libcpp_is_unsigned_integer<_Tp>::value,"__rotl requires unsigned");`
`479`	`467`	`using __nlt = numeric_limits<_Tp>;`
`480`	`468`
`481`	`469`	`return ((__cnt % __nlt::digits) ==0) ?`
`@@ -488,7 +476,7 @@ template<class _Tp>`
`488`	`476`	`_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_BIT_CONSTEXPR`
`489`	`477`	`_Tp__rotr(_Tp__t,unsignedint __cnt) _NOEXCEPT`
`490`	`478`	`{`
`491`		`-static_assert(__bitop_unsigned_integer<_Tp>::value,"__rotr requires unsigned");`
	`479`	`+static_assert(__libcpp_is_unsigned_integer<_Tp>::value,"__rotr requires unsigned");`
`492`	`480`	`using __nlt = numeric_limits<_Tp>;`
`493`	`481`
`494`	`482`	`return ((__cnt % __nlt::digits) ==0) ?`
`@@ -551,7 +539,7 @@ template<class _Tp>`
`551`	`539`	`_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_BIT_CONSTEXPR`
`552`	`540`	`int__countr_zero(_Tp__t) _NOEXCEPT`
`553`	`541`	`{`
`554`		`-static_assert(__bitop_unsigned_integer<_Tp>::value,"__countr_zero requires unsigned");`
	`542`	`+static_assert(__libcpp_is_unsigned_integer<_Tp>::value,"__countr_zero requires unsigned");`
`555`	`543`
`556`	`544`	`return__t ?__countr_zero_dispatch(__t) : numeric_limits<_Tp>::digits;`
`557`	`545`	`}`
`@@ -619,15 +607,15 @@ template<class _Tp>`
`619`	`607`	`_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_BIT_CONSTEXPR`
`620`	`608`	`int__countl_zero(_Tp__t) _NOEXCEPT`
`621`	`609`	`{`
`622`		`-static_assert(__bitop_unsigned_integer<_Tp>::value,"__countl_zero requires unsigned");`
	`610`	`+static_assert(__libcpp_is_unsigned_integer<_Tp>::value,"__countl_zero requires unsigned");`
`623`	`611`	`return__t ?__countl_zero_dispatch(__t) : numeric_limits<_Tp>::digits;`
`624`	`612`	`}`
`625`	`613`
`626`	`614`	`template<class_Tp>`
`627`	`615`	`_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_BIT_CONSTEXPR`
`628`	`616`	`int__countl_one(_Tp__t) _NOEXCEPT`
`629`	`617`	`{`
`630`		`-static_assert(__bitop_unsigned_integer<_Tp>::value,"__countl_one requires unsigned");`
	`618`	`+static_assert(__libcpp_is_unsigned_integer<_Tp>::value,"__countl_one requires unsigned");`
`631`	`619`	`return__t != numeric_limits<_Tp>::max()`
`632`	`620`	`?__countl_zero(static_cast<_Tp>(~__t))`
`633`	`621`	`: numeric_limits<_Tp>::digits;`
`@@ -638,7 +626,7 @@ template<class _Tp>`
`638`	`626`	`_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_BIT_CONSTEXPR`
`639`	`627`	`int__countr_one(_Tp__t) _NOEXCEPT`
`640`	`628`	`{`
`641`		`-static_assert(__bitop_unsigned_integer<_Tp>::value,"__countr_one requires unsigned");`
	`629`	`+static_assert(__libcpp_is_unsigned_integer<_Tp>::value,"__countr_one requires unsigned");`
`642`	`630`	`return__t != numeric_limits<_Tp>::max()`
`643`	`631`	`?__countr_zero(static_cast<_Tp>(~__t))`
`644`	`632`	`: numeric_limits<_Tp>::digits;`
`@@ -681,7 +669,7 @@ template<class _Tp>`
`681`	`669`	`_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_BIT_CONSTEXPR`
`682`	`670`	`int__popcount(_Tp__t) _NOEXCEPT`
`683`	`671`	`{`
`684`		`-static_assert(__bitop_unsigned_integer<_Tp>::value,"__libcpp_popcount requires unsigned");`
	`672`	`+static_assert(__libcpp_is_unsigned_integer<_Tp>::value,"__libcpp_popcount requires unsigned");`
`685`	`673`
`686`	`674`	`return__popcount_dispatch(__t);`
`687`	`675`	`}`
`@@ -692,15 +680,15 @@ template<class _Tp>`
`692`	`680`	`_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_BIT_CONSTEXPR`
`693`	`681`	`unsigned__bit_log2(_Tp__t) _NOEXCEPT`
`694`	`682`	`{`
`695`		`-static_assert(__bitop_unsigned_integer<_Tp>::value,"__bit_log2 requires unsigned");`
	`683`	`+static_assert(__libcpp_is_unsigned_integer<_Tp>::value,"__bit_log2 requires unsigned");`
`696`	`684`	`return std::numeric_limits<_Tp>::digits -1 -__countl_zero(__t);`
`697`	`685`	`}`
`698`	`686`
`699`	`687`	`template<class_Tp>`
`700`	`688`	`_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_BIT_CONSTEXPR`
`701`	`689`	`bool__has_single_bit(_Tp__t) _NOEXCEPT`
`702`	`690`	`{`
`703`		`-static_assert(__bitop_unsigned_integer<_Tp>::value,"__has_single_bit requires unsigned");`
	`691`	`+static_assert(__libcpp_is_unsigned_integer<_Tp>::value,"__has_single_bit requires unsigned");`
`704`	`692`	`return__t !=0 && (((__t & (__t -1)) ==0));`
`705`	`693`	`}`
`706`	`694`
`@@ -734,7 +722,7 @@ __ceil2(_Tp __t) noexcept`
`734`	`722`
`735`	`723`	`template<class_Tp>`
`736`	`724`	`_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_BIT_CONSTEXPR`
`737`		`-__enable_if_t<__bitop_unsigned_integer<_Tp>::value, _Tp>`
	`725`	`+__enable_if_t<__libcpp_is_unsigned_integer<_Tp>::value, _Tp>`
`738`	`726`	`rotl(_Tp__t,unsignedint __cnt)noexcept`
`739`	`727`	`{`
`740`	`728`	`return__rotl(__t, __cnt);`
`@@ -744,7 +732,7 @@ rotl(_Tp __t, unsigned int __cnt) noexcept`
`744`	`732`	`// rotr`
`745`	`733`	`template<class_Tp>`
`746`	`734`	`_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_BIT_CONSTEXPR`
`747`		`-__enable_if_t<__bitop_unsigned_integer<_Tp>::value, _Tp>`
	`735`	`+__enable_if_t<__libcpp_is_unsigned_integer<_Tp>::value, _Tp>`
`748`	`736`	`rotr(_Tp__t,unsignedint __cnt)noexcept`
`749`	`737`	`{`
`750`	`738`	`return__rotr(__t, __cnt);`
`@@ -753,7 +741,7 @@ rotr(_Tp __t, unsigned int __cnt) noexcept`
`753`	`741`
`754`	`742`	`template<class_Tp>`
`755`	`743`	`_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_BIT_CONSTEXPR`
`756`		`-__enable_if_t<__bitop_unsigned_integer<_Tp>::value,int>`
	`744`	`+__enable_if_t<__libcpp_is_unsigned_integer<_Tp>::value,int>`
`757`	`745`	`countl_zero(_Tp__t)noexcept`
`758`	`746`	`{`
`759`	`747`	`return__countl_zero(__t);`
`@@ -762,7 +750,7 @@ countl_zero(_Tp __t) noexcept`
`762`	`750`
`763`	`751`	`template<class_Tp>`
`764`	`752`	`_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_BIT_CONSTEXPR`
`765`		`-__enable_if_t<__bitop_unsigned_integer<_Tp>::value,int>`
	`753`	`+__enable_if_t<__libcpp_is_unsigned_integer<_Tp>::value,int>`
`766`	`754`	`countl_one(_Tp__t)noexcept`
`767`	`755`	`{`
`768`	`756`	`return__countl_one(__t);`
`@@ -771,7 +759,7 @@ countl_one(_Tp __t) noexcept`
`771`	`759`
`772`	`760`	`template<class_Tp>`
`773`	`761`	`_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_BIT_CONSTEXPR`
`774`		`-__enable_if_t<__bitop_unsigned_integer<_Tp>::value,int>`
	`762`	`+__enable_if_t<__libcpp_is_unsigned_integer<_Tp>::value,int>`
`775`	`763`	`countr_zero(_Tp__t)noexcept`
`776`	`764`	`{`
`777`	`765`	`return__countr_zero(__t);`
`@@ -780,7 +768,7 @@ countr_zero(_Tp __t) noexcept`
`780`	`768`
`781`	`769`	`template<class_Tp>`
`782`	`770`	`_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_BIT_CONSTEXPR`
`783`		`-__enable_if_t<__bitop_unsigned_integer<_Tp>::value,int>`
	`771`	`+__enable_if_t<__libcpp_is_unsigned_integer<_Tp>::value,int>`
`784`	`772`	`countr_one(_Tp__t)noexcept`
`785`	`773`	`{`
`786`	`774`	`return__countr_one(__t);`
`@@ -789,7 +777,7 @@ countr_one(_Tp __t) noexcept`
`789`	`777`
`790`	`778`	`template<class_Tp>`
`791`	`779`	`_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_BIT_CONSTEXPR`
`792`		`-__enable_if_t<__bitop_unsigned_integer<_Tp>::value,int>`
	`780`	`+__enable_if_t<__libcpp_is_unsigned_integer<_Tp>::value,int>`
`793`	`781`	`popcount(_Tp__t)noexcept`
`794`	`782`	`{`
`795`	`783`	`return__popcount(__t);`
`@@ -798,31 +786,31 @@ popcount(_Tp __t) noexcept`
`798`	`786`
`799`	`787`	`template<class_Tp>`
`800`	`788`	`_LIBCUDACXX_INLINE_VISIBILITYconstexpr`
`801`		`-__enable_if_t<__bitop_unsigned_integer<_Tp>::value,bool>`
	`789`	`+__enable_if_t<__libcpp_is_unsigned_integer<_Tp>::value,bool>`
`802`	`790`	`has_single_bit(_Tp__t)noexcept`
`803`	`791`	`{`
`804`	`792`	`return__has_single_bit(__t);`
`805`	`793`	`}`
`806`	`794`
`807`	`795`	`template<class_Tp>`
`808`	`796`	`_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_BIT_CONSTEXPR`
`809`		`-__enable_if_t<__bitop_unsigned_integer<_Tp>::value, _Tp>`
	`797`	`+__enable_if_t<__libcpp_is_unsigned_integer<_Tp>::value, _Tp>`
`810`	`798`	`bit_floor(_Tp__t)noexcept`
`811`	`799`	`{`
`812`	`800`	`return__t ==0 ?0 :static_cast<_Tp>(_Tp{1} <<__bit_log2(__t));`
`813`	`801`	`}`
`814`	`802`
`815`	`803`	`template<class_Tp>`
`816`	`804`	`_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_BIT_CONSTEXPR`
`817`		`-__enable_if_t<__bitop_unsigned_integer<_Tp>::value, _Tp>`
	`805`	`+__enable_if_t<__libcpp_is_unsigned_integer<_Tp>::value, _Tp>`
`818`	`806`	`bit_ceil(_Tp__t)noexcept`
`819`	`807`	`{`
`820`	`808`	`return (__t <2) ?1 :static_cast<_Tp>(__ceil2(__t));`
`821`	`809`	`}`
`822`	`810`
`823`	`811`	`template<class_Tp>`
`824`	`812`	`_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_BIT_CONSTEXPR`
`825`		`-__enable_if_t<__bitop_unsigned_integer<_Tp>::value, _Tp>`
	`813`	`+__enable_if_t<__libcpp_is_unsigned_integer<_Tp>::value, _Tp>`
`826`	`814`	`bit_width(_Tp__t)noexcept`
`827`	`815`	`{`
`828`	`816`	`return__t ==0 ?0 :static_cast<_Tp>(__bit_log2(__t) +1);`

`‎include/cuda/std/detail/libcxx/include/optional‎`

Lines changed: 4 additions & 0 deletions

Original file line number	Diff line number	Diff line change
`@@ -1610,4 +1610,8 @@ _LIBCUDACXX_END_NAMESPACE_STD`
`1610`	`1610`
`1611`	`1611`	`#endif// _LIBCUDACXX_STD_VER > 11`
`1612`	`1612`
	`1613`	`+#ifndef __cuda_std__`
	`1614`	`+#include<__pragma_pop>`
	`1615`	`+#endif// __cuda_std__`
	`1616`	`+`
`1613`	`1617`	`#endif// _LIBCUDACXX_OPTIONAL`

`‎include/cuda/std/detail/libcxx/include/tuple‎`

Lines changed: 4 additions & 9 deletions

Original file line number	Diff line number	Diff line change
`@@ -1050,17 +1050,12 @@ tuple(allocator_arg_t, _Alloc, tuple<_Tp...>) -> tuple<_Tp...>;`
`1050`	`1050`
`1051`	`1051`	`template<class ..._Tp>`
`1052`	`1052`	`inline _LIBCUDACXX_INLINE_VISIBILITY`
`1053`		`-typename enable_if`
`1054`		`-<`
`1055`		`- __all<__is_swappable<_Tp>::value...>::value,`
`1056`		`-void`
`1057`		`->::type`
`1058`		`-swap(tuple<_Tp...>&__t, tuple<_Tp...>& __u)`
`1059`		`- _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)`
`1060`		`- {__t.swap(__u);}`
	`1053`	`+__enable_if_t<_And<__is_swappable<_Tp>...>::value,void>`
	`1054`	`+swap(tuple<_Tp...>&__t, tuple<_Tp...>& __u) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value) {`
	`1055`	`+__t.swap(__u);`
	`1056`	`+}`
`1061`	`1057`
`1062`	`1058`	`// get`
`1063`		`-`
`1064`	`1059`	`template<size_t _Ip,class ..._Tp>`
`1065`	`1060`	`inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11`
`1066`	`1061`	`typename tuple_element<_Ip, tuple<_Tp...> >::type&`

`‎libcxx/test/libcxx/modules/cinttypes_exports.sh.cpp‎`

Lines changed: 1 addition & 0 deletions

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@`
`9`	`9`	`// This test fails on Windows because the underlying libc headers on Windows`
`10`	`10`	`// are not modular`
`11`	`11`	`// XFAIL: LIBCXX-WINDOWS-FIXME`
	`12`	`+// XFAIL: clang-9, clang-10`
`12`	`13`
`13`	`14`	`// REQUIRES: modules-support`
`14`	`15`

`‎libcxx/test/libcxx/modules/clocale_exports.sh.cpp‎`

Lines changed: 1 addition & 0 deletions

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@`
`9`	`9`	`// This test fails on Windows because the underlying libc headers on Windows`
`10`	`10`	`// are not modular`
`11`	`11`	`// XFAIL: LIBCXX-WINDOWS-FIXME`
	`12`	`+// XFAIL: clang-9, clang-10`
`12`	`13`
`13`	`14`	`// REQUIRES: modules-support`
`14`	`15`	`// UNSUPPORTED: c++98, c++03`

`‎libcxx/test/libcxx/modules/cstdint_exports.sh.cpp‎`

Lines changed: 1 addition & 0 deletions

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@`
`9`	`9`	`// This test fails on Windows because the underlying libc headers on Windows`
`10`	`10`	`// are not modular`
`11`	`11`	`// XFAIL: LIBCXX-WINDOWS-FIXME`
	`12`	`+// XFAIL: clang-9, clang-10`
`12`	`13`
`13`	`14`	`// REQUIRES: modules-support`
`14`	`15`

`‎libcxx/test/libcxx/modules/inttypes_h_exports.sh.cpp‎`

Lines changed: 1 addition & 0 deletions

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@`
`9`	`9`	`// This test fails on Windows because the underlying libc headers on Windows`
`10`	`10`	`// are not modular`
`11`	`11`	`// XFAIL: LIBCXX-WINDOWS-FIXME`
	`12`	`+// XFAIL: clang-9, clang-10`
`12`	`13`
`13`	`14`	`// REQUIRES: modules-support`
`14`	`15`

`‎libcxx/test/libcxx/modules/stdint_h_exports.sh.cpp‎`

Lines changed: 2 additions & 0 deletions

Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,8 @@`
`6`	`6`	`//`
`7`	`7`	`//===----------------------------------------------------------------------===//`
`8`	`8`
	`9`	`+// XFAIL: clang-9, clang-10`
	`10`	`+`
`9`	`11`	`// REQUIRES: modules-support`
`10`	`12`
`11`	`13`	`// Test that int8_t and the like are exported from stdint.h not inttypes.h`

`‎libcxx/test/libcxx/thread/thread.threads/thread.thread.this/sleep_for.pass.cpp‎`

Lines changed: 2 additions & 1 deletion

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,8 @@`
`8`	`8`	`//`
`9`	`9`	`// UNSUPPORTED: libcpp-has-no-threads`
`10`	`10`
`11`		`-// FLAKY_TEST.`
	`11`	`+// Threading tests are notoriously flaky in libcxx mode so disable them`
	`12`	`+// UNSUPPORTED: true`
`12`	`13`
`13`	`14`	`// This test uses the POSIX header <sys/time.h> which Windows doesn't provide`
`14`	`15`	`// UNSUPPORTED: windows`

0 commit comments

Comments

(0)

Movatterモバイル変換

Navigation Menu

Search code, repositories, users, issues, pull requests...

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Commit070697d

File tree

73 files changed

Some content is hidden

73 files changed

`‎include/cuda/std/detail/libcxx/include/__memory/construct_at.h‎`

`‎include/cuda/std/detail/libcxx/include/bit‎`

`‎include/cuda/std/detail/libcxx/include/optional‎`

`‎include/cuda/std/detail/libcxx/include/tuple‎`

`‎libcxx/test/libcxx/modules/cinttypes_exports.sh.cpp‎`

`‎libcxx/test/libcxx/modules/clocale_exports.sh.cpp‎`

`‎libcxx/test/libcxx/modules/cstdint_exports.sh.cpp‎`

`‎libcxx/test/libcxx/modules/inttypes_h_exports.sh.cpp‎`

`‎libcxx/test/libcxx/modules/stdint_h_exports.sh.cpp‎`

`‎libcxx/test/libcxx/thread/thread.threads/thread.thread.this/sleep_for.pass.cpp‎`

0 commit comments