[libc++] Remove <cstdlib> includes

[philnik]

Summary

We changed the abort calls when trying to throw exceptions in -fno-exceptions mode to __verbose_abort calls, which removes the dependency in most files.

[philnik]

Try to fix CI

[ldionne]

Can you explain that those are not necessary anymore since we moved to __verbose_abort in your commit message? Thanks for the patch, LGTM!

[philnik]

Try to fix CI

[philnik]

Rebased

[philnik]

@emaste @dim Could you please take a look at the CI failure?

[dim]

Hm, seems the actual error is:

In file included from <module-includes>:34:
In file included from /home/buildkite/.buildkite-agent/builds/freebsd-test-1/llvm-project/libcxx-ci/build/generic-cxx2b/include/c++/v1/complex.h:27:
In file included from /home/buildkite/.buildkite-agent/builds/freebsd-test-1/llvm-project/libcxx-ci/build/generic-cxx2b/include/c++/v1/ccomplex:21:
In file included from /home/buildkite/.buildkite-agent/builds/freebsd-test-1/llvm-project/libcxx-ci/build/generic-cxx2b/include/c++/v1/complex:242:
In file included from /home/buildkite/.buildkite-agent/builds/freebsd-test-1/llvm-project/libcxx-ci/build/generic-cxx2b/include/c++/v1/sstream:191:
In file included from /home/buildkite/.buildkite-agent/builds/freebsd-test-1/llvm-project/libcxx-ci/build/generic-cxx2b/include/c++/v1/istream:169:
In file included from /home/buildkite/.buildkite-agent/builds/freebsd-test-1/llvm-project/libcxx-ci/build/generic-cxx2b/include/c++/v1/ostream:178:
/home/buildkite/.buildkite-agent/builds/freebsd-test-1/llvm-project/libcxx-ci/build/generic-cxx2b/include/c++/v1/locale:762:26: error: use of undeclared identifier 'strtoll_l'; did you mean 'wcstoll_l'?
        long long __ll = strtoll_l(__a, &__p2, __base, _LIBCPP_GET_C_LOCALE);
                         ^

so it could be that we define strtoll_l in an unexpected place. As far as I remember our locale headers were slightly different from other systems... I can't look for a fix right now as it's too late here, but maybe @emaste has some time :)

[emaste]

Our definition is in /usr/include/xlocale/_stdlib.h which has the comment:

/*
 * Extended locale versions of the locale-aware functions from stdlib.h.
 *
 * Include <stdlib.h> before <xlocale.h> to expose these.
 */
...
long long                strtoll_l(const char *, char **, int, locale_t);
...

/usr/include/xlocal.h:

#ifdef _STDLIB_H_
#include <xlocale/_stdlib.h>
#endif

but there is also this in stdlib.h:

#ifdef _XLOCALE_H_
#include <xlocale/_stdlib.h>
#endif

which was added in:

commit 3ac9d659890471a1936268bfec06e74caf9025df
Author: David Chisnall <[e-mail]>
Date:   Wed Mar 28 12:11:54 2012 +0000

    Correctly expose xlocale functions if people include the headers in the wrong
    order (as some ports apparently do).
    
    Approved by:    dim (mentor)

Notes:
    svn path=/head/; revision=233600

[philnik]

Try to fix CI

[philnik]

Try to fix CI

[philnik]

Next try

libcxx/include/__bit/byteswap.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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___BIT_BYTESWAP_H
 #define _LIBCPP___BIT_BYTESWAP_H
 
 #include <__concepts/arithmetic.h>
 #include <__config>
 #include <cstdint>
-#include <cstdlib>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 23

libcxx/include/__expected/expected.h

 #include <__type_traits/remove_cv.h>
 #include <__type_traits/remove_cvref.h>
 #include <__utility/exception_guard.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <__verbose_abort>
-#include <cstdlib> // for std::abort
 #include <initializer_list>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER >= 23
 

libcxx/include/__filesystem/directory_entry.h

 #include <__filesystem/file_time_type.h>
 #include <__filesystem/file_type.h>
 #include <__filesystem/filesystem_error.h>
 #include <__filesystem/operations.h>
 #include <__filesystem/path.h>
 #include <__filesystem/perms.h>
 #include <__utility/unreachable.h>
 #include <cstdint>
-#include <cstdlib>
 #include <iosfwd>
 #include <system_error>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__iterator/advance.h

 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_integral.h>
 #include <__utility/convert_to_integral.h>
 #include <__utility/declval.h>
 #include <__utility/move.h>
 #include <__utility/unreachable.h>
-#include <cstdlib>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/__locale

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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___LOCALE
 #define _LIBCPP___LOCALE
 
 #include <__availability>
 #include <__config>
 #include <cctype>
 #include <cstdint>
+#include <cstdlib>
 #include <locale.h>
 #include <mutex>
 #include <string>
 
 // Some platforms require more includes than others. Keep the includes on all plaforms for now.
 #include <cstddef>
 #include <cstring>
 

libcxx/include/__memory/shared_ptr.h

 #include <__type_traits/remove_extent.h>
 #include <__type_traits/remove_reference.h>
 #include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <__verbose_abort>
 #include <cstddef>
-#include <cstdlib> // abort
 #include <iosfwd>
 #include <new>
 #include <stdexcept>
 #include <typeinfo>
 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 #  include <__atomic/memory_order.h>
 #endif
 

libcxx/include/algorithm

 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
 #  include <chrono>
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <bit>
 #  include <concepts>
+#  include <cstdlib>
 #  include <cstring>
 #  include <iterator>
 #  include <memory>
 #  include <stdexcept>
 #  include <type_traits>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_ALGORITHM

libcxx/include/any

 #include <__type_traits/remove_cv.h>
 #include <__type_traits/remove_cvref.h>
 #include <__type_traits/remove_reference.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/move.h>
 #include <__utility/unreachable.h>
 #include <__verbose_abort>
-#include <cstdlib>
 #include <initializer_list>
 #include <typeinfo>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
 #  include <chrono>
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
+#  include <cstdlib>
 #  include <iosfwd>
 #  include <iterator>
 #  include <memory>
 #  include <type_traits>
 #  include <variant>
 #endif
 
 #endif // _LIBCPP_ANY

libcxx/include/array

 
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <concepts>
+#  include <cstdlib>
 #  include <iterator>
 #  include <type_traits>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_ARRAY

libcxx/include/bit

 #include <__config>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <cstdlib>
 #  include <iosfwd>
 #  include <limits>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_BIT

libcxx/include/bitset

 operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x);
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
+#  include <cstdlib>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_BITSET

libcxx/include/charconv

 #include <__charconv/to_chars_integral.h>
 #include <__charconv/to_chars_result.h>
 #include <__charconv/traits.h>
 #include <__config>
 #include <__debug>
 #include <__errc>
 #include <cmath> // for log2f
 #include <cstdint>
-#include <cstdlib>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
+#  include <cstdlib>
 #  include <cstring>
 #  include <iosfwd>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_CHARCONV

libcxx/include/deque

 #endif
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <atomic>
 #  include <concepts>
+#  include <cstdlib>
 #  include <functional>
 #  include <iosfwd>
 #  include <iterator>
 #  include <type_traits>
 #  include <typeinfo>
 #endif
 
 #endif // _LIBCPP_DEQUE

libcxx/include/experimental/memory_resource

 
  */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__memory/allocator_traits.h>
 #include <__type_traits/aligned_storage.h>
 #include <__utility/move.h>
 #include <cstddef>
-#include <cstdlib>
 #include <experimental/__config>
 #include <experimental/__memory>
 #include <limits>
 #include <new>
 #include <stdexcept>
 #include <tuple>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

 _LIBCPP_END_NAMESPACE_LFTS_PMR
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <climits>
 #  include <concepts>
+#  include <cstdlib>
 #  include <cstring>
 #  include <ctime>
 #  include <iterator>
 #  include <memory>
 #  include <ratio>
 #  include <type_traits>
 #  include <variant>
 #endif
 
 #endif /* _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE */

libcxx/include/filesystem

 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
+#  include <cstdlib>
 #endif
 
 #endif // _LIBCPP_FILESYSTEM

libcxx/include/forward_list

 #endif
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <atomic>
 #  include <concepts>
+#  include <cstdlib>
 #  include <functional>
 #  include <iosfwd>
 #  include <iterator>
 #  include <type_traits>
 #  include <typeinfo>
 #endif
 
 #endif // _LIBCPP_FORWARD_LIST

libcxx/include/fstream

 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__config>
 #include <__locale>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <__utility/unreachable.h>
 #include <cstdio>
-#include <cstdlib>
 #include <istream>
 #include <ostream>
 #include <typeinfo>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
 #   include <filesystem>
 #endif

 
 #endif // _LIBCPP_HAS_NO_FSTREAM
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
+#  include <cstdlib>
 #  include <iosfwd>
 #  include <limits>
 #  include <new>
 #  include <stdexcept>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_FSTREAM

libcxx/include/functional

 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
+#  include <cstdlib>
 #  include <exception>
 #  include <tuple>
 #  include <type_traits>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_FUNCTIONAL

libcxx/include/future

 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
 #  include <chrono>
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
+#  include <cstdlib>
 #  include <exception>
 #endif
 
 #endif // _LIBCPP_FUTURE

libcxx/include/iterator

 #include <compare>
 #include <concepts>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <cstdlib>
 #  include <exception>
 #  include <new>
 #  include <type_traits>
 #  include <typeinfo>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_ITERATOR

libcxx/include/list

 #endif
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <atomic>
 #  include <concepts>
+#  include <cstdlib>
 #  include <functional>
 #  include <iosfwd>
 #  include <iterator>
 #  include <type_traits>
 #  include <typeinfo>
 #endif
 
 #endif // _LIBCPP_LIST

libcxx/include/map

 template <class _KeyT, class _ValueT, class _CompareT = std::less<_KeyT>>
 using multimap = std::multimap<_KeyT, _ValueT, _CompareT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>;
 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
+#  include <cstdlib>
 #  include <functional>
 #  include <iterator>
 #  include <type_traits>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_MAP

libcxx/include/memory

 #   include <__pstl_memory>
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
 #  include <cstddef>
 #  include <cstdint>
+#  include <cstdlib>
 #  include <cstring>
 #  include <iosfwd>
 #  include <iterator>
 #  include <new>
 #  include <stdexcept>
 #  include <tuple>
 #  include <type_traits>
 #  include <typeinfo>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_MEMORY

libcxx/include/ostream

 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<wchar_t>;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
+#  include <cstdlib>
 #  include <iterator>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_OSTREAM

libcxx/include/queue

struct _LIBCPP_TEMPLATE_VIS uses_allocator<priority_queue<_Tp, _Container, _Compare>, _Alloc>
     : public uses_allocator<_Container, _Alloc>
 {
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
+#  include <cstdlib>
 #  include <functional>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_QUEUE

libcxx/include/random

 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <climits>
 #  include <cmath>
 #  include <concepts>
 #  include <cstddef>
 #  include <cstdint>
+#  include <cstdlib>
 #  include <iosfwd>
 #  include <limits>
 #  include <numeric>
 #  include <string>
 #  include <type_traits>
 #  include <vector>
 #endif
 
 #endif // _LIBCPP_RANDOM

libcxx/include/ranges

 #include <__tuple_dir/tuple_element.h>
 #include <__tuple_dir/tuple_size.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <cstdlib>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_RANGES

libcxx/include/regex

 _LIBCPP_END_NAMESPACE_STD
 #endif
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
+#  include <cstdlib>
 #  include <iosfwd>
 #  include <iterator>
 #  include <new>
 #  include <type_traits>
 #  include <typeinfo>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_REGEX

libcxx/include/set

 template <class _KeyT, class _CompareT = std::less<_KeyT>>
 using multiset = std::multiset<_KeyT, _CompareT, polymorphic_allocator<_KeyT>>;
 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
+#  include <cstdlib>
 #  include <functional>
 #  include <iterator>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_SET

libcxx/include/stdexcept

 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__exception/exception.h>
-#include <cstdlib>
+#include <__verbose_abort>
 #include <iosfwd>  // for string forward decl
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

 #else
     _LIBCPP_VERBOSE_ABORT("underflow_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
 #endif
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <cstdlib>
 #  include <exception>
 #endif
 
 #endif // _LIBCPP_STDEXCEPT

libcxx/include/string

 #include <__type_traits/remove_cvref.h>
 #include <__utility/auto_cast.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <__utility/unreachable.h>
 #include <climits>
 #include <cstdint>
 #include <cstdio>  // EOF
-#include <cstdlib>
 #include <cstring>
 #include <limits>
 #include <stdexcept>
 #include <string_view>
 #include <version>
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #  include <cwchar>

 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <concepts>
+#  include <cstdlib>
 #  include <functional>
 #  include <iterator>
 #  include <new>
 #  include <type_traits>
 #  include <typeinfo>
 #  include <utility>
 #  include <vector>
 #endif
 
 #endif // _LIBCPP_STRING

libcxx/include/string_view

 #endif
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <concepts>
+#  include <cstdlib>
 #  include <functional>
 #  include <iterator>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_STRING_VIEW

libcxx/include/typeinfo

 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__config>
 #include <__exception/exception.h>
 #include <__type_traits/is_constant_evaluated.h>
 #include <__verbose_abort>
 #include <cstddef>
 #include <cstdint>
-#include <cstdlib>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if defined(_LIBCPP_ABI_VCRUNTIME)
 #include <vcruntime_typeinfo.h>
 #else
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw bad_cast();
 #else
     _LIBCPP_VERBOSE_ABORT("bad_cast was thrown in -fno-exceptions mode");
 #endif
 }
 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <cstdlib>
 #  include <exception>
 #  include <type_traits>
 #endif
 
 #endif // __LIBCPP_TYPEINFO

libcxx/include/unordered_map

 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <bit>
 #  include <concepts>
+#  include <cstdlib>
 #  include <iterator>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_UNORDERED_MAP

libcxx/include/unordered_set

 template <class _KeyT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>>
 using unordered_multiset = std::unordered_multiset<_KeyT, _HashT, _PredT, polymorphic_allocator<_KeyT>>;
 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
+#  include <cstdlib>
 #  include <functional>
 #  include <iterator>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_UNORDERED_SET

libcxx/include/valarray

 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <concepts>
+#  include <cstdlib>
 #  include <cstring>
 #  include <functional>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_VALARRAY

libcxx/include/vector

 #include <__type_traits/is_nothrow_move_assignable.h>
 #include <__type_traits/noexcept_move_assign_container.h>
 #include <__type_traits/type_identity.h>
 #include <__utility/exception_guard.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <climits>
-#include <cstdlib>
 #include <cstring>
 #include <iosfwd> // for forward declaration of vector
 #include <limits>
 #include <stdexcept>
 #include <version>
 
 // standard-mandated includes
 

 #endif
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <atomic>
 #  include <concepts>
+#  include <cstdlib>
 #  include <type_traits>
 #  include <typeinfo>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_VECTOR

libcxx/test/libcxx/transitive_includes/cxx03.csv

 deque typeinfo
 deque version
 exception cstddef
 exception cstdlib
 exception type_traits
 exception version
 execution version
 expected cstddef
-expected cstdlib
 expected initializer_list
 expected new
 expected version
 experimental/deque deque
 experimental/deque experimental/memory_resource
 experimental/forward_list experimental/memory_resource
 experimental/forward_list forward_list
 experimental/iterator cstddef

libcxx/test/libcxx/transitive_includes/cxx11.csv

 deque typeinfo
 deque version
 exception cstddef
 exception cstdlib
 exception type_traits
 exception version
 execution version
 expected cstddef
-expected cstdlib
 expected initializer_list
 expected new
 expected version
 experimental/deque deque
 experimental/deque experimental/memory_resource
 experimental/forward_list experimental/memory_resource
 experimental/forward_list forward_list
 experimental/iterator cstddef

libcxx/test/libcxx/transitive_includes/cxx14.csv

 deque typeinfo
 deque version
 exception cstddef
 exception cstdlib
 exception type_traits
 exception version
 execution version
 expected cstddef
-expected cstdlib
 expected initializer_list
 expected new
 expected version
 experimental/deque deque
 experimental/deque experimental/memory_resource
 experimental/forward_list experimental/memory_resource
 experimental/forward_list forward_list
 experimental/iterator cstddef

libcxx/test/libcxx/transitive_includes/cxx17.csv

 deque typeinfo
 deque version
 exception cstddef
 exception cstdlib
 exception type_traits
 exception version
 execution version
 expected cstddef
-expected cstdlib
 expected initializer_list
 expected new
 expected version
 experimental/deque deque
 experimental/deque experimental/memory_resource
 experimental/forward_list experimental/memory_resource
 experimental/forward_list forward_list
 experimental/iterator cstddef

libcxx/test/libcxx/transitive_includes/cxx20.csv

 deque typeinfo
 deque version
 exception cstddef
 exception cstdlib
 exception type_traits
 exception version
 execution version
 expected cstddef
-expected cstdlib
 expected initializer_list
 expected new
 expected version
 experimental/deque deque
 experimental/deque experimental/memory_resource
 experimental/forward_list experimental/memory_resource
 experimental/forward_list forward_list
 experimental/iterator cstddef

libcxx/test/libcxx/transitive_includes/cxx2b.csv

 algorithm climits
 algorithm cstddef
 algorithm cstdint
-algorithm cstdlib
 algorithm cstring
 algorithm initializer_list
 algorithm iosfwd
 algorithm limits
 algorithm new
 algorithm version
 any cstddef
 any cstdint
-any cstdlib
 any cstring
 any initializer_list
 any limits
 any new
 any stdexcept
 any typeinfo
 any version
 array compare
 array cstddef
-array cstdlib
 array initializer_list
 array limits
 array stdexcept
 array version
 atomic cstddef
 atomic cstdint
 atomic cstdlib
 atomic cstring
 atomic ctime
 atomic iosfwd
 atomic limits
 atomic ratio
 atomic version
 barrier cstddef
 barrier cstdint
 barrier cstring
 barrier ctime
 barrier iosfwd
 barrier limits
 barrier new
 barrier ratio
 barrier version
 bit cstdint
-bit cstdlib
 bit limits
 bit version
 bitset climits
 bitset cstddef
 bitset cstdint
-bitset cstdlib
 bitset cstring
 bitset initializer_list
 bitset iosfwd
 bitset limits
 bitset new
 bitset stdexcept
 bitset string
 bitset version
 ccomplex complex
 charconv cerrno
 charconv cmath
 charconv cstddef
 charconv cstdint
-charconv cstdlib
 charconv initializer_list
 charconv limits
 chrono array
 chrono cmath
 chrono compare
 chrono cstddef
 chrono cstdint
 chrono cstdlib

 chrono tuple
 chrono vector
 chrono version
 cinttypes cstdint
 cmath version
 codecvt cctype
 codecvt cstddef
 codecvt cstdint
+codecvt cstdlib
 codecvt cstring
 codecvt mutex
 codecvt string
 codecvt version
 compare cmath
 compare cstddef
 compare cstdint
 compare limits
 compare version
 complex cmath
 complex iosfwd
 complex sstream
 complex stdexcept
 complex version
 concepts cstddef
 concepts version
 condition_variable cstddef
-condition_variable cstdlib
 condition_variable ctime
 condition_variable iosfwd
 condition_variable limits
 condition_variable new
 condition_variable ratio
 condition_variable stdexcept
 condition_variable system_error
 condition_variable typeinfo
 condition_variable version
 coroutine compare
 coroutine cstddef
 coroutine cstdint
 coroutine cstring
 coroutine limits
 coroutine version
 cstddef version
 ctgmath ccomplex
 ctgmath cmath
 cwchar cwctype
 cwctype cctype
 deque compare
 deque cstddef
 deque cstdint
-deque cstdlib
 deque cstring
 deque initializer_list
 deque limits
 deque new
 deque stdexcept
 deque tuple
 deque version
 exception cstddef
 exception cstdlib
 exception version
 execution version
 expected cstddef
-expected cstdlib
 expected initializer_list
 expected new
 expected version
 experimental/deque deque
 experimental/deque experimental/memory_resource
 experimental/forward_list experimental/memory_resource
 experimental/forward_list forward_list
 experimental/iterator cstddef
 experimental/iterator iosfwd
 experimental/iterator iterator
 experimental/list experimental/memory_resource
 experimental/list list
 experimental/map experimental/memory_resource
 experimental/map map
 experimental/memory_resource cstddef
-experimental/memory_resource cstdlib
 experimental/memory_resource experimental/utility
 experimental/memory_resource limits
 experimental/memory_resource new
 experimental/memory_resource stdexcept
 experimental/memory_resource tuple
 experimental/propagate_const cstddef
 experimental/regex experimental/memory_resource
 experimental/regex experimental/string

 ext/hash_set initializer_list
 ext/hash_set limits
 ext/hash_set new
 ext/hash_set string
 filesystem cerrno
 filesystem compare
 filesystem cstddef
 filesystem cstdint
-filesystem cstdlib
 filesystem ctime
 filesystem iomanip
 filesystem iosfwd
 filesystem limits
 filesystem locale
 filesystem new
 filesystem ratio
 filesystem string

 format string
 format string_view
 format tuple
 format vector
 format version
 forward_list compare
 forward_list cstddef
 forward_list cstdint
-forward_list cstdlib
 forward_list cstring
 forward_list initializer_list
 forward_list limits
 forward_list new
 forward_list stdexcept
 forward_list tuple
 forward_list version
 fstream cctype
 fstream cstddef
 fstream cstdint
 fstream cstdio
 fstream cstdlib
 fstream cstring
 fstream filesystem
 fstream initializer_list
 fstream istream
 fstream mutex
 fstream ostream
 fstream string
 fstream typeinfo
 fstream version
 functional array
 functional cstddef
 functional cstdint
-functional cstdlib
 functional cstring
 functional initializer_list
 functional iosfwd
 functional limits
 functional memory
 functional new
 functional stdexcept
 functional tuple

 future typeinfo
 future version
 initializer_list cstddef
 iomanip istream
 iomanip version
 ios cctype
 ios cstddef
 ios cstdint
+ios cstdlib
 ios cstring
 ios iosfwd
 ios mutex
 ios string
 ios system_error
 ios version
 iosfwd version
 iostream ios
 iostream istream
 iostream ostream
 iostream streambuf
 iostream version
 istream cstddef
 istream iosfwd
 istream ostream
 istream version
 iterator compare
 iterator concepts
 iterator cstddef
-iterator cstdlib
 iterator initializer_list
 iterator iosfwd
 iterator limits
 iterator variant
 iterator version
 latch cstddef
 latch cstdint
 latch cstring
 latch ctime
 latch iosfwd
 latch limits
 latch ratio
 latch version
 limits version
 list compare
 list cstddef
 list cstdint
-list cstdlib
 list cstring
 list initializer_list
 list limits
 list new
 list stdexcept
 list tuple
 list version
 locale cctype

 locale limits
 locale mutex
 locale new
 locale streambuf
 locale string
 locale version
 map compare
 map cstddef
-map cstdlib
 map initializer_list
 map limits
 map new
 map optional
 map stdexcept
 map tuple
 map version
 memory compare
 memory cstddef
 memory cstdint
-memory cstdlib
 memory cstring
 memory initializer_list
 memory iosfwd
 memory limits
 memory new
 memory stdexcept
 memory tuple
 memory typeinfo
 memory version
 memory_resource cstddef
 memory_resource cstdint
 memory_resource limits
 memory_resource mutex
 memory_resource new
 memory_resource stdexcept
 memory_resource tuple
 memory_resource version
 mutex cstddef
 mutex cstdint
-mutex cstdlib
 mutex ctime
 mutex iosfwd
 mutex limits
 mutex new
 mutex ratio
 mutex stdexcept
 mutex system_error
 mutex tuple

 optional initializer_list
 optional limits
 optional new
 optional stdexcept
 optional version
 ostream bitset
 ostream cstddef
 ostream cstdint
-ostream cstdlib
 ostream cstring
 ostream initializer_list
 ostream ios
 ostream iosfwd
 ostream limits
 ostream locale
 ostream new
 ostream stdexcept
 ostream streambuf
 ostream typeinfo
 ostream version
 queue compare
 queue cstddef
-queue cstdlib
 queue deque
 queue initializer_list
 queue limits
 queue vector
 queue version
 random cmath
 random cstddef
 random cstdint
-random cstdlib
 random initializer_list
 random iosfwd
 random limits
 random numeric
 random string
 random vector
 random version
 ranges compare
 ranges cstddef
-ranges cstdlib
 ranges initializer_list
 ranges iosfwd
 ranges iterator
 ranges limits
 ranges new
 ranges optional
 ranges span
 ranges tuple

 semaphore cstring
 semaphore ctime
 semaphore iosfwd
 semaphore limits
 semaphore ratio
 semaphore version
 set compare
 set cstddef
-set cstdlib
 set initializer_list
 set limits
 set new
 set optional
 set stdexcept
 set tuple
 set version
 shared_mutex cerrno

 sstream ostream
 sstream string
 sstream version
 stack compare
 stack cstddef
 stack deque
 stack initializer_list
 stack version
-stdexcept cstdlib
 stdexcept iosfwd
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string climits
 string compare
 string cstddef
 string cstdint
 string cstdio
-string cstdlib
 string cstring
 string cwchar
 string initializer_list
 string iosfwd
 string limits
 string new
 string stdexcept
 string string_view
 string tuple
 string version
 string_view compare
 string_view cstddef
 string_view cstdint
 string_view cstdio
-string_view cstdlib
 string_view cstring
 string_view cwchar
 string_view initializer_list
 string_view iosfwd
 string_view limits
 string_view stdexcept
 string_view version
 strstream istream

 type_traits cstddef
 type_traits cstdint
 type_traits version
 typeindex compare
 typeindex typeinfo
 typeindex version
 typeinfo cstddef
 typeinfo cstdint
-typeinfo cstdlib
 unordered_map cmath
 unordered_map compare
 unordered_map cstddef
 unordered_map cstdint
-unordered_map cstdlib
 unordered_map cstring
 unordered_map initializer_list
 unordered_map limits
 unordered_map new
 unordered_map optional
 unordered_map stdexcept
 unordered_map tuple
 unordered_map version
 unordered_set cmath
 unordered_set compare
 unordered_set cstddef
 unordered_set cstdint
-unordered_set cstdlib
 unordered_set cstring
 unordered_set initializer_list
 unordered_set limits
 unordered_set new
 unordered_set optional
 unordered_set stdexcept
 unordered_set tuple
 unordered_set version
 utility compare
 utility cstddef
 utility initializer_list
 utility limits
 utility version
 valarray cmath
 valarray cstddef
 valarray cstdint
-valarray cstdlib
 valarray initializer_list
 valarray limits
 valarray new
 valarray stdexcept
 valarray version
 variant compare
 variant cstddef
 variant cstdint
 variant cstring
 variant initializer_list
 variant limits
 variant new
 variant tuple
 variant version
 vector climits
 vector compare
 vector cstddef
 vector cstdint
-vector cstdlib
 vector cstring
 vector initializer_list
 vector iosfwd
 vector limits
 vector new
 vector stdexcept
 vector tuple
 vector version

libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp

 
 // template<class IntType = int>
 // class discrete_distribution
 
 // template<class _URNG> result_type operator()(_URNG& g);
 
 #include <cassert>
 #include <cstdint>
+#include <cstdlib>
 #include <random>
 #include <vector>
 
 #include "test_macros.h"
 
 template <class T>
 void tests() {
     typedef long long Frequency;

libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/eval_param.pass.cpp

 
 // <random>
 
 // template<class IntType = int>
 // class discrete_distribution
 
 // template<class _URNG> result_type operator()(_URNG& g, const param_type& parm);
 
+#include <cassert>
+#include <cstdlib>
 #include <random>
 #include <vector>
-#include <cassert>
-
-#include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
         typedef D::param_type P;
         typedef std::minstd_rand G;
         G g;