diff options
Diffstat (limited to 'libcxx')
| -rw-r--r-- | libcxx/docs/index.rst | 2 | ||||
| -rw-r--r-- | libcxx/include/CMakeLists.txt | 2 | ||||
| -rw-r--r-- | libcxx/include/__algorithm/comp.h | 4 | ||||
| -rw-r--r-- | libcxx/include/__algorithm/find.h | 2 | ||||
| -rw-r--r-- | libcxx/include/__functional/is_transparent.h | 8 | ||||
| -rw-r--r-- | libcxx/include/__functional/operations.h | 18 | ||||
| -rw-r--r-- | libcxx/include/__functional/ranges_operations.h | 7 | ||||
| -rw-r--r-- | libcxx/include/__tree | 4 | ||||
| -rw-r--r-- | libcxx/include/__type_traits/is_generic_transparent_comparator.h | 30 | ||||
| -rw-r--r-- | libcxx/include/__type_traits/make_transparent.h | 48 | ||||
| -rw-r--r-- | libcxx/include/map | 54 | ||||
| -rw-r--r-- | libcxx/include/module.modulemap.in | 2 | ||||
| -rw-r--r-- | libcxx/include/string | 16 | ||||
| -rw-r--r-- | libcxx/test/benchmarks/containers/associative/map.bench.cpp | 13 | ||||
| -rw-r--r-- | libcxx/test/benchmarks/containers/associative/unordered_map.bench.cpp | 13 | ||||
| -rw-r--r-- | libcxx/test/std/experimental/simd/simd.class/simd_unary.pass.cpp | 3 | ||||
| -rw-r--r-- | libcxx/test/std/language.support/support.exception/propagation/make_exception_ptr.objc.pass.mm | 3 | ||||
| -rw-r--r-- | libcxx/utils/libcxx/test/params.py | 3 |
18 files changed, 221 insertions, 11 deletions
diff --git a/libcxx/docs/index.rst b/libcxx/docs/index.rst index a44c316..4d5064b 100644 --- a/libcxx/docs/index.rst +++ b/libcxx/docs/index.rst @@ -133,7 +133,7 @@ velocity, libc++ drops support for older compilers as newer ones are released. Compiler Versions Restrictions Support policy ============ =================== ========================== ===================== Clang 19, 20, 21-git latest two stable releases per `LLVM's release page <https://releases.llvm.org>`_ and the development version -AppleClang 16.4 latest stable release per `Xcode's release page <https://developer.apple.com/documentation/xcode-release-notes>`_ +AppleClang 26.0 latest stable release per `Xcode's release page <https://developer.apple.com/documentation/xcode-release-notes>`_ Open XL 17.1.3 (AIX) latest stable release per `Open XL's documentation page <https://www.ibm.com/docs/en/openxl-c-and-cpp-aix>`_ GCC 15 In C++11 or later only latest stable release per `GCC's release page <https://gcc.gnu.org/releases.html>`_ ============ =================== ========================== ===================== diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt index e050362..ddace8b 100644 --- a/libcxx/include/CMakeLists.txt +++ b/libcxx/include/CMakeLists.txt @@ -839,6 +839,7 @@ set(files __type_traits/is_floating_point.h __type_traits/is_function.h __type_traits/is_fundamental.h + __type_traits/is_generic_transparent_comparator.h __type_traits/is_implicit_lifetime.h __type_traits/is_implicitly_default_constructible.h __type_traits/is_integral.h @@ -881,6 +882,7 @@ set(files __type_traits/make_32_64_or_128_bit.h __type_traits/make_const_lvalue_ref.h __type_traits/make_signed.h + __type_traits/make_transparent.h __type_traits/make_unsigned.h __type_traits/maybe_const.h __type_traits/nat.h diff --git a/libcxx/include/__algorithm/comp.h b/libcxx/include/__algorithm/comp.h index ab3c598..38e2fb9 100644 --- a/libcxx/include/__algorithm/comp.h +++ b/libcxx/include/__algorithm/comp.h @@ -11,6 +11,7 @@ #include <__config> #include <__type_traits/desugars_to.h> +#include <__type_traits/is_generic_transparent_comparator.h> #include <__type_traits/is_integral.h> #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) @@ -48,6 +49,9 @@ inline const bool __desugars_to_v<__less_tag, __less<>, _Tp, _Tp> = true; template <class _Tp> inline const bool __desugars_to_v<__totally_ordered_less_tag, __less<>, _Tp, _Tp> = is_integral<_Tp>::value; +template <> +inline const bool __is_generic_transparent_comparator_v<__less<> > = true; + _LIBCPP_END_NAMESPACE_STD #endif // _LIBCPP___ALGORITHM_COMP_H diff --git a/libcxx/include/__algorithm/find.h b/libcxx/include/__algorithm/find.h index 5f32ae8..72e201a 100644 --- a/libcxx/include/__algorithm/find.h +++ b/libcxx/include/__algorithm/find.h @@ -69,7 +69,7 @@ _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp* __find_vectorized(_Tp* __first, _Tp* __last, auto __orig_first = __first; - auto __values = static_cast<__simd_vector<_Up, __vec_size>>(__value); // broadcast the value + auto __values = static_cast<__simd_vector<_Tp, __vec_size>>(__value); // broadcast the value while (static_cast<size_t>(__last - __first) >= __unroll_count * __vec_size) [[__unlikely__]] { __vec __lhs[__unroll_count]; diff --git a/libcxx/include/__functional/is_transparent.h b/libcxx/include/__functional/is_transparent.h index 567df1a..c2c6fbc 100644 --- a/libcxx/include/__functional/is_transparent.h +++ b/libcxx/include/__functional/is_transparent.h @@ -29,6 +29,14 @@ inline const bool __is_transparent_v<_Tp, _Key, __void_t<typename _Tp::is_transp #endif +// Two types are considered transparently comparable if `comparator(key, arg)` is equivalent to `comparator(key, +// <implicit cast to KeyT>(arg))`. +// +// This is different from `__is_transparent_v`, which is only a property of the comparator and doesn't provide +// additional semantic guarantees. +template <class _Comparator, class _KeyT, class _Arg, class = void> +inline const bool __is_transparently_comparable_v = false; + _LIBCPP_END_NAMESPACE_STD #endif // _LIBCPP___FUNCTIONAL_IS_TRANSPARENT diff --git a/libcxx/include/__functional/operations.h b/libcxx/include/__functional/operations.h index 7b0ea11..7f315ca 100644 --- a/libcxx/include/__functional/operations.h +++ b/libcxx/include/__functional/operations.h @@ -15,7 +15,9 @@ #include <__functional/unary_function.h> #include <__fwd/functional.h> #include <__type_traits/desugars_to.h> +#include <__type_traits/is_generic_transparent_comparator.h> #include <__type_traits/is_integral.h> +#include <__type_traits/make_transparent.h> #include <__utility/forward.h> #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) @@ -377,6 +379,14 @@ struct less<void> { typedef void is_transparent; }; +template <class _Tp> +struct __make_transparent<less<_Tp> > { + using type _LIBCPP_NODEBUG = less<>; +}; + +template <> +inline const bool __is_generic_transparent_comparator_v<less<>> = true; + template <class _Tp, class _Up> inline const bool __desugars_to_v<__less_tag, less<>, _Tp, _Up> = true; @@ -466,6 +476,14 @@ struct greater<void> { template <class _Tp, class _Up> inline const bool __desugars_to_v<__greater_tag, greater<>, _Tp, _Up> = true; + +template <class _Tp> +struct __make_transparent<greater<_Tp>> { + using type _LIBCPP_NODEBUG = greater<>; +}; + +template <> +inline const bool __is_generic_transparent_comparator_v<greater<>> = true; #endif // Logical operations diff --git a/libcxx/include/__functional/ranges_operations.h b/libcxx/include/__functional/ranges_operations.h index df95843..dc9da06 100644 --- a/libcxx/include/__functional/ranges_operations.h +++ b/libcxx/include/__functional/ranges_operations.h @@ -14,6 +14,7 @@ #include <__concepts/totally_ordered.h> #include <__config> #include <__type_traits/desugars_to.h> +#include <__type_traits/is_generic_transparent_comparator.h> #include <__utility/forward.h> #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) @@ -108,6 +109,12 @@ inline const bool __desugars_to_v<__less_tag, ranges::less, _Tp, _Up> = true; template <class _Tp, class _Up> inline const bool __desugars_to_v<__greater_tag, ranges::greater, _Tp, _Up> = true; +template <> +inline const bool __is_generic_transparent_comparator_v<ranges::less> = true; + +template <> +inline const bool __is_generic_transparent_comparator_v<ranges::greater> = true; + #endif // _LIBCPP_STD_VER >= 20 _LIBCPP_END_NAMESPACE_STD diff --git a/libcxx/include/__tree b/libcxx/include/__tree index 61c910c..ef960d4 100644 --- a/libcxx/include/__tree +++ b/libcxx/include/__tree @@ -34,6 +34,7 @@ #include <__type_traits/is_same.h> #include <__type_traits/is_specialization.h> #include <__type_traits/is_swappable.h> +#include <__type_traits/make_transparent.h> #include <__type_traits/remove_const.h> #include <__utility/forward.h> #include <__utility/lazy_synth_three_way_comparator.h> @@ -1749,7 +1750,8 @@ __tree<_Tp, _Compare, _Allocator>::__find_equal(const _Key& __v) { } __node_base_pointer* __node_ptr = __root_ptr(); - auto __comp = __lazy_synth_three_way_comparator<_Compare, _Key, value_type>(value_comp()); + auto&& __transparent = std::__as_transparent(value_comp()); + auto __comp = __lazy_synth_three_way_comparator<__make_transparent_t<_Compare>, _Key, value_type>(__transparent); while (true) { auto __comp_res = __comp(__v, __nd->__get_value()); diff --git a/libcxx/include/__type_traits/is_generic_transparent_comparator.h b/libcxx/include/__type_traits/is_generic_transparent_comparator.h new file mode 100644 index 0000000..fd02c0b --- /dev/null +++ b/libcxx/include/__type_traits/is_generic_transparent_comparator.h @@ -0,0 +1,30 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___TYPE_TRAITS_IS_GENERIC_TRANSPARENT_COMPARATOR_H +#define _LIBCPP___TYPE_TRAITS_IS_GENERIC_TRANSPARENT_COMPARATOR_H + +#include <__config> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +// This traits returns true if the given _Comparator is known to accept any two types for compaison. This is separate +// from `__is_transparent_v`, since that only enables overloads of specific functions, but doesn't give any semantic +// guarantees. This trait guarantess that the comparator simply calls the appropriate comparison functions for any two +// types. + +template <class _Comparator> +inline const bool __is_generic_transparent_comparator_v = false; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___TYPE_TRAITS_IS_GENERIC_TRANSPARENT_COMPARATOR_H diff --git a/libcxx/include/__type_traits/make_transparent.h b/libcxx/include/__type_traits/make_transparent.h new file mode 100644 index 0000000..4d3207a --- /dev/null +++ b/libcxx/include/__type_traits/make_transparent.h @@ -0,0 +1,48 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___TYPE_TRAITS_MAKE_TRANSPARENT_H +#define _LIBCPP___TYPE_TRAITS_MAKE_TRANSPARENT_H + +#include <__config> +#include <__type_traits/enable_if.h> +#include <__type_traits/is_empty.h> +#include <__type_traits/is_same.h> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +// __make_transparent tries to create a transparent comparator from its non-transparent counterpart, e.g. obtain +// `less<>` from `less<T>`. This is useful in cases where conversions can be avoided (e.g. a string literal to a +// std::string). + +template <class _Comparator> +struct __make_transparent { + using type _LIBCPP_NODEBUG = _Comparator; +}; + +template <class _Comparator> +using __make_transparent_t _LIBCPP_NODEBUG = typename __make_transparent<_Comparator>::type; + +template <class _Comparator, __enable_if_t<is_same<_Comparator, __make_transparent_t<_Comparator> >::value, int> = 0> +_LIBCPP_HIDE_FROM_ABI _Comparator& __as_transparent(_Comparator& __comp) { + return __comp; +} + +template <class _Comparator, __enable_if_t<!is_same<_Comparator, __make_transparent_t<_Comparator> >::value, int> = 0> +_LIBCPP_HIDE_FROM_ABI __make_transparent_t<_Comparator> __as_transparent(_Comparator&) { + static_assert(is_empty<_Comparator>::value); + return __make_transparent_t<_Comparator>(); +} + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___TYPE_TRAITS_MAKE_TRANSPARENT_H diff --git a/libcxx/include/map b/libcxx/include/map index a63dfec..035f913 100644 --- a/libcxx/include/map +++ b/libcxx/include/map @@ -600,7 +600,10 @@ erase_if(multimap<Key, T, Compare, Allocator>& c, Predicate pred); // C++20 # include <__ranges/from_range.h> # include <__tree> # include <__type_traits/container_traits.h> +# include <__type_traits/desugars_to.h> # include <__type_traits/is_allocator.h> +# include <__type_traits/is_convertible.h> +# include <__type_traits/make_transparent.h> # include <__type_traits/remove_const.h> # include <__type_traits/type_identity.h> # include <__utility/forward.h> @@ -666,6 +669,11 @@ public: # endif }; +template <class _Key, class _MapValueT, class _Compare> +struct __make_transparent<__map_value_compare<_Key, _MapValueT, _Compare> > { + using type _LIBCPP_NODEBUG = __map_value_compare<_Key, _MapValueT, __make_transparent_t<_Compare> >; +}; + # if _LIBCPP_STD_VER >= 14 template <class _MapValueT, class _Key, class _Compare> struct __lazy_synth_three_way_comparator<__map_value_compare<_Key, _MapValueT, _Compare>, _MapValueT, _MapValueT> { @@ -1048,6 +1056,24 @@ public: _LIBCPP_HIDE_FROM_ABI mapped_type& operator[](key_type&& __k); # endif + template <class _Arg, + __enable_if_t<__is_transparently_comparable_v<_Compare, key_type, __remove_cvref_t<_Arg> >, int> = 0> + _LIBCPP_HIDE_FROM_ABI mapped_type& at(_Arg&& __arg) { + auto [_, __child] = __tree_.__find_equal(__arg); + if (__child == nullptr) + std::__throw_out_of_range("map::at: key not found"); + return static_cast<__node_pointer>(__child)->__get_value().second; + } + + template <class _Arg, + __enable_if_t<__is_transparently_comparable_v<_Compare, key_type, __remove_cvref_t<_Arg> >, int> = 0> + _LIBCPP_HIDE_FROM_ABI const mapped_type& at(_Arg&& __arg) const { + auto [_, __child] = __tree_.__find_equal(__arg); + if (__child == nullptr) + std::__throw_out_of_range("map::at: key not found"); + return static_cast<__node_pointer>(__child)->__get_value().second; + } + _LIBCPP_HIDE_FROM_ABI mapped_type& at(const key_type& __k); _LIBCPP_HIDE_FROM_ABI const mapped_type& at(const key_type& __k) const; @@ -1242,11 +1268,15 @@ public: _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __tree_.find(__k); } _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __tree_.find(__k); } # if _LIBCPP_STD_VER >= 14 - template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0> + template <typename _K2, + enable_if_t<__is_transparent_v<_Compare, _K2> || __is_transparently_comparable_v<_Compare, key_type, _K2>, + int> = 0> _LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) { return __tree_.find(__k); } - template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0> + template <typename _K2, + enable_if_t<__is_transparent_v<_Compare, _K2> || __is_transparently_comparable_v<_Compare, key_type, _K2>, + int> = 0> _LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const { return __tree_.find(__k); } @@ -1262,7 +1292,9 @@ public: # if _LIBCPP_STD_VER >= 20 _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); } - template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0> + template <typename _K2, + enable_if_t<__is_transparent_v<_Compare, _K2> || __is_transparently_comparable_v<_Compare, key_type, _K2>, + int> = 0> _LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const { return find(__k) != end(); } @@ -1271,12 +1303,16 @@ public: _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const key_type& __k) { return __tree_.lower_bound(__k); } _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const key_type& __k) const { return __tree_.lower_bound(__k); } # if _LIBCPP_STD_VER >= 14 - template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0> + template <typename _K2, + enable_if_t<__is_transparent_v<_Compare, _K2> || __is_transparently_comparable_v<_Compare, key_type, _K2>, + int> = 0> _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const _K2& __k) { return __tree_.lower_bound(__k); } - template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0> + template <typename _K2, + enable_if_t<__is_transparent_v<_Compare, _K2> || __is_transparently_comparable_v<_Compare, key_type, _K2>, + int> = 0> _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const _K2& __k) const { return __tree_.lower_bound(__k); } @@ -1285,11 +1321,15 @@ public: _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const key_type& __k) { return __tree_.upper_bound(__k); } _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const key_type& __k) const { return __tree_.upper_bound(__k); } # if _LIBCPP_STD_VER >= 14 - template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0> + template <typename _K2, + enable_if_t<__is_transparent_v<_Compare, _K2> || __is_transparently_comparable_v<_Compare, key_type, _K2>, + int> = 0> _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const _K2& __k) { return __tree_.upper_bound(__k); } - template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0> + template <typename _K2, + enable_if_t<__is_transparent_v<_Compare, _K2> || __is_transparently_comparable_v<_Compare, key_type, _K2>, + int> = 0> _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const _K2& __k) const { return __tree_.upper_bound(__k); } diff --git a/libcxx/include/module.modulemap.in b/libcxx/include/module.modulemap.in index 93d43f8..894093b 100644 --- a/libcxx/include/module.modulemap.in +++ b/libcxx/include/module.modulemap.in @@ -200,6 +200,7 @@ module std_core [system] { header "__type_traits/is_fundamental.h" export std_core.type_traits.integral_constant } + module is_generic_transparent_comparator { header "__type_traits/is_generic_transparent_comparator.h" } module is_implicit_lifetime { header "__type_traits/is_implicit_lifetime.h" export std_core.type_traits.integral_constant @@ -353,6 +354,7 @@ module std_core [system] { module make_32_64_or_128_bit { header "__type_traits/make_32_64_or_128_bit.h" } module make_const_lvalue_ref { header "__type_traits/make_const_lvalue_ref.h" } module make_signed { header "__type_traits/make_signed.h" } + module make_transparent { header "__type_traits/make_transparent.h" } module make_unsigned { header "__type_traits/make_unsigned.h" } module maybe_const { header "__type_traits/maybe_const.h" } module nat { header "__type_traits/nat.h" } diff --git a/libcxx/include/string b/libcxx/include/string index cfd6861..dc562e0 100644 --- a/libcxx/include/string +++ b/libcxx/include/string @@ -600,6 +600,7 @@ basic_string<char32_t> operator""s( const char32_t *str, size_t len ); # include <__debug_utils/sanitizers.h> # include <__format/enable_insertable.h> # include <__functional/hash.h> +# include <__functional/is_transparent.h> # include <__functional/unary_function.h> # include <__fwd/string.h> # include <__iterator/bounded_iter.h> @@ -628,6 +629,7 @@ basic_string<char32_t> operator""s( const char32_t *str, size_t len ); # include <__type_traits/is_allocator.h> # include <__type_traits/is_array.h> # include <__type_traits/is_convertible.h> +# include <__type_traits/is_generic_transparent_comparator.h> # include <__type_traits/is_nothrow_assignable.h> # include <__type_traits/is_nothrow_constructible.h> # include <__type_traits/is_replaceable.h> @@ -2567,6 +2569,20 @@ struct __default_three_way_comparator<basic_string<_CharT, _Traits, _Alloc>, bas }; # endif +template <class _Comparator, class _CharT, class _Traits, class _Alloc> +inline const bool __is_transparently_comparable_v<_Comparator, + basic_string<_CharT, _Traits, _Alloc>, + const _CharT*, + __enable_if_t<__is_generic_transparent_comparator_v<_Comparator> > > = + true; + +template <class _Comparator, class _CharT, class _Traits, class _Alloc, size_t _Np> +inline const bool __is_transparently_comparable_v<_Comparator, + basic_string<_CharT, _Traits, _Alloc>, + _CharT[_Np], + __enable_if_t<__is_generic_transparent_comparator_v<_Comparator> > > = + true; + # if _LIBCPP_STD_VER >= 17 template <class _InputIterator, class _CharT = __iter_value_type<_InputIterator>, diff --git a/libcxx/test/benchmarks/containers/associative/map.bench.cpp b/libcxx/test/benchmarks/containers/associative/map.bench.cpp index bd664db..142229a 100644 --- a/libcxx/test/benchmarks/containers/associative/map.bench.cpp +++ b/libcxx/test/benchmarks/containers/associative/map.bench.cpp @@ -16,6 +16,19 @@ #include "../../GenerateInput.h" #include "benchmark/benchmark.h" +static void BM_map_find_string_literal(benchmark::State& state) { + std::map<std::string, int> map; + map.emplace("Something very very long to show a long string situation", 1); + map.emplace("Something Else", 2); + + for (auto _ : state) { + benchmark::DoNotOptimize(map); + benchmark::DoNotOptimize(map.find("Something very very long to show a long string situation")); + } +} + +BENCHMARK(BM_map_find_string_literal); + template <class K, class V> struct support::adapt_operations<std::map<K, V>> { using ValueType = typename std::map<K, V>::value_type; diff --git a/libcxx/test/benchmarks/containers/associative/unordered_map.bench.cpp b/libcxx/test/benchmarks/containers/associative/unordered_map.bench.cpp index 57adec2..d670c53 100644 --- a/libcxx/test/benchmarks/containers/associative/unordered_map.bench.cpp +++ b/libcxx/test/benchmarks/containers/associative/unordered_map.bench.cpp @@ -15,6 +15,19 @@ #include "../../GenerateInput.h" #include "benchmark/benchmark.h" +static void BM_map_find_string_literal(benchmark::State& state) { + std::unordered_map<std::string, int> map; + map.emplace("Something very very long to show a long string situation", 1); + map.emplace("Something Else", 2); + + for (auto _ : state) { + benchmark::DoNotOptimize(map); + benchmark::DoNotOptimize(map.find("Something very very long to show a long string situation")); + } +} + +BENCHMARK(BM_map_find_string_literal); + template <class K, class V> struct support::adapt_operations<std::unordered_map<K, V>> { using ValueType = typename std::unordered_map<K, V>::value_type; diff --git a/libcxx/test/std/experimental/simd/simd.class/simd_unary.pass.cpp b/libcxx/test/std/experimental/simd/simd.class/simd_unary.pass.cpp index 056d6f6..2c3751a 100644 --- a/libcxx/test/std/experimental/simd/simd.class/simd_unary.pass.cpp +++ b/libcxx/test/std/experimental/simd/simd.class/simd_unary.pass.cpp @@ -12,6 +12,9 @@ // Assertion failed: N->getValueType(0) == MVT::v1i1 && "Expected v1i1 type" // XFAIL: target=armv7-unknown-linux-gnueabihf +// FIXME: This should work with -flax-vector-conversions=none +// ADDITIONAL_COMPILE_FLAGS(clang): -flax-vector-conversions=integer + // <experimental/simd> // // [simd.class] diff --git a/libcxx/test/std/language.support/support.exception/propagation/make_exception_ptr.objc.pass.mm b/libcxx/test/std/language.support/support.exception/propagation/make_exception_ptr.objc.pass.mm index 05a6698..de38305 100644 --- a/libcxx/test/std/language.support/support.exception/propagation/make_exception_ptr.objc.pass.mm +++ b/libcxx/test/std/language.support/support.exception/propagation/make_exception_ptr.objc.pass.mm @@ -17,7 +17,8 @@ // out-of-the-box. // REQUIRES: has-fobjc-arc && darwin -// ADDITIONAL_COMPILE_FLAGS: -fobjc-arc +// FIXME: including <Foundation/Foundation.h> seems to be currently broken with modules enabled +// ADDITIONAL_COMPILE_FLAGS: -fobjc-arc -fno-modules #include <cassert> #include <exception> diff --git a/libcxx/utils/libcxx/test/params.py b/libcxx/utils/libcxx/test/params.py index 6f013a7..c02d6df 100644 --- a/libcxx/utils/libcxx/test/params.py +++ b/libcxx/utils/libcxx/test/params.py @@ -75,6 +75,9 @@ _warningFlags = [ # We're not annotating all the APIs, since that's a lot of annotations compared to how many we actually care about "-Wno-nullability-completeness", + + # Technically not a warning flag, but might as well be: + "-flax-vector-conversions=none", ] _allStandards = ["c++03", "c++11", "c++14", "c++17", "c++20", "c++23", "c++26"] |