[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/docs/ReleaseNotes.rst

 - The ``<experimental/coroutine>`` header has been removed in this release. The ``<coroutine>`` header
   has been shipping since LLVM 14, so the Coroutines TS implementation is being removed per our policy
   for removing TSes.
 
 - Several incidental transitive includes have been removed from libc++. Those
   includes are removed based on the language version used. Incidental transitive
   inclusions of the following headers have been removed:
 
-  - C++2b: ``atomic``, ``bit``, ``cstring``, ``type_traits``
+  - C++2b: ``atomic``, ``bit``, ``cstdlib``, ``cstring``, ``type_traits``
 
 - The headers ``<experimental/algorithm>`` and ``<experimental/functional>`` have been removed, since all the contents
   have been implemented in namespace ``std`` for at least two releases.
 
 - The formatter specialization ``template<size_t N> struct formatter<const charT[N], charT>``
   has been removed. Since libc++'s format library was marked experimental there
   is no backwards compatibility option. This specialization has been removed
   from the Standard since it was never used, the proper specialization to use

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/__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 <__errc>
 #include <__memory/addressof.h>
 #include <__type_traits/is_unsigned.h>
 #include <__type_traits/make_32_64_or_128_bit.h>
 #include <__type_traits/make_unsigned.h>
 #include <__utility/unreachable.h>
 #include <cmath> // for log2f
 #include <cstdint>
-#include <cstdlib>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

 #endif // _LIBCPP_STD_VER >= 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #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/condition_variable

 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // !_LIBCPP_HAS_NO_THREADS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
+#  include <cstdlib>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_CONDITION_VARIABLE

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 <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>
 #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/locale

 #include <__iterator/access.h>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/istreambuf_iterator.h>
 #include <__iterator/ostreambuf_iterator.h>
 #include <__locale>
 #include <__memory/unique_ptr.h>
 #include <__type_traits/make_unsigned.h>
 #include <cstdio>
-#include <cstdlib>
 #include <ctime>
 #include <ios>
 #include <limits>
 #include <new>
 #include <streambuf>
 #include <version>
 
 // TODO: Fix __bsd_locale_defaults.h

 _LIBCPP_POP_MACROS
 
 // NOLINTEND(libcpp-robust-against-adl)
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
 #  include <cstdarg>
+#  include <cstdlib>
 #  include <iterator>
 #  include <stdexcept>
 #  include <type_traits>
 #  include <typeinfo>
 #endif
 
 #endif // _LIBCPP_LOCALE

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/mutex

 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
+#  include <cstdlib>
 #  include <ctime>
 #  include <functional>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_MUTEX

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 <__verbose_abort>
-#include <cstdlib>
 #include <exception>
 #include <iosfwd>  // for string forward decl
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw underflow_error(__msg);
 #else
     std::__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>
+#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 <__type_traits/is_constant_evaluated.h>
 #include <__verbose_abort>
 #include <cstddef>
 #include <cstdint>
-#include <cstdlib>
 #include <exception>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if defined(_LIBCPP_ABI_VCRUNTIME)
 #include <vcruntime_typeinfo.h>
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw bad_cast();
 #else
     std::__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 <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 exception
 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

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 exception
 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

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 exception
 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

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 exception
 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

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 exception
 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

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 charconv
 chrono cmath
 chrono compare
 chrono cstddef
 chrono cstdint

 complex iosfwd
 complex sstream
 complex stdexcept
 complex version
 concepts cstddef
 concepts version
 condition_variable cstddef
 condition_variable cstdint
-condition_variable cstdlib
 condition_variable cstring
 condition_variable ctime
 condition_variable initializer_list
 condition_variable iosfwd
 condition_variable limits
 condition_variable new
 condition_variable ratio
 condition_variable stdexcept

 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 exception
 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 exception
 functional initializer_list
 functional iosfwd
 functional limits
 functional memory
 functional new
 functional stdexcept
 functional tuple
 functional typeinfo
 functional unordered_map
 functional vector
 functional version
 future cstddef
 future cstdint
-future cstdlib
 future cstring
 future exception
 future initializer_list
 future iosfwd
 future limits
 future mutex
 future new
 future ratio

 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 cstddef
 locale cstdint
 locale cstdio
-locale cstdlib
 locale cstring
 locale ctime
 locale initializer_list
 locale ios
 locale iosfwd
 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 cstring
 mutex ctime
 mutex initializer_list
 mutex iosfwd
 mutex limits
 mutex new
 mutex ratio
 mutex stdexcept

 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
 ranges variant
 ranges version
 ratio climits
 ratio cstdint
 ratio version
 regex cctype
 regex compare
 regex cstddef
 regex cstdint
-regex cstdlib
 regex cstring
 regex deque
 regex initializer_list
 regex limits
 regex mutex
 regex stdexcept
 regex string
 regex vector
 regex version
 scoped_allocator cstddef
 scoped_allocator limits
 scoped_allocator new
 scoped_allocator tuple
 scoped_allocator version
 semaphore cstddef
 semaphore cstdint
 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 cstddef

 sstream ostream
 sstream string
 sstream version
 stack compare
 stack cstddef
 stack deque
 stack initializer_list
 stack version
-stdexcept cstdlib
 stdexcept exception
 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
 typeinfo exception
 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 exception
 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;