[libc++] Fix some tests that were broken in the single-threaded configuration

[ldionne]

Summary

We never noticed it because our CI doesn't actually build against a C
library that doesn't have threading functionality, however building
against a truly thread-free platform surfaces these issues.

[Mordante]

LGTM when the CI is happy. Should we add a CI that test this configuration?

[ldionne]

In D114242#3142762, @Mordante wrote:

LGTM when the CI is happy. Should we add a CI that test this configuration?

Thanks for the review. We have CI for that configuration, however we don't have an actual C library that lacks support for threads. So we do have coverage, but it's not perfect. For each "freestanding slice" configuration, we could in theory create a small C library that forwards everything to the underlying C library, but which doesn't have the functionality we're excluding from that slice. But I believe that would reach diminishing returns.

[Mordante]

In D114242#3142767, @ldionne wrote:

In D114242#3142762, @Mordante wrote:

LGTM when the CI is happy. Should we add a CI that test this configuration?

Thanks for the review. We have CI for that configuration, however we don't have an actual C library that lacks support for threads. So we do have coverage, but it's not perfect. For each "freestanding slice" configuration, we could in theory create a small C library that forwards everything to the underlying C library, but which doesn't have the functionality we're excluding from that slice. But I believe that would reach diminishing returns.

Fair point. At some point it would be nice to have an actual "freestanding" C library for these test purposes. But I agree it would be a waste of our time to try to create that. (Unless we have somebody with too much time on their hands ;-) )

[jloser]

libcxx/utils/generate_feature_test_macro_components.py

657

I find it interesting that including <thread> would be a hard error rather than a no-op like other "unsupported features" when it comes to including other headers (like ranges, concepts, etc.). No action required, but just an observation.

[ldionne]

In D114242#3142796, @Mordante wrote:

Fair point. At some point it would be nice to have an actual "freestanding" C library for these test purposes. But I agree it would be a waste of our time to try to create that. (Unless we have somebody with too much time on their hands ;-) )

Well, I wouldn't say it would be a waste of time -- I think it would be super useful and in fact it could help formalize what it means to support various levels of Freestanding, even for other C++ Standard Library implementations. However, yeah, it's not the highest on the priority list.

libcxx/utils/generate_feature_test_macro_components.py

657

We do have some inconsistency around that, however all features like "no-localization", "no-wide-characters", "no-random-device" are hard errors, and I think it makes the most sense. Indeed, what we're trying to model here is a platform that literally does not support these features. For example, on some platforms, you literally can't include <wchar.h>, because there is no such header. Putting an #error on our side is what models that best IMO.

Features like concepts are somewhat different, in that it's a matter of compiler support, where we try to be flexible and accommodate compilers that have incomplete support for X.

[jloser]

libcxx/utils/generate_feature_test_macro_components.py

657

Makes sense - thanks for the discussion.

[Mordante]

In D114242#3142869, @ldionne wrote:

In D114242#3142796, @Mordante wrote:

Fair point. At some point it would be nice to have an actual "freestanding" C library for these test purposes. But I agree it would be a waste of our time to try to create that. (Unless we have somebody with too much time on their hands ;-) )

Well, I wouldn't say it would be a waste of time -- I think it would be super useful and in fact it could help formalize what it means to support various levels of Freestanding, even for other C++ Standard Library implementations. However, yeah, it's not the highest on the priority list.

Don't get me wrong, I would love to have better support for non-hosted builds. But I think it would be better to see whether we can use an existing non-hosted C library instead of writing our own. Maybe it would be possible to use LLVM's libc for that purpose. That is if we can easily disable some of their features.

[ldionne]

In D114242#3143335, @Mordante wrote:

Don't get me wrong, I would love to have better support for non-hosted builds. But I think it would be better to see whether we can use an existing non-hosted C library instead of writing our own. Maybe it would be possible to use LLVM's libc for that purpose. That is if we can easily disable some of their features.

That's actually an interesting idea, I had not thought about that.

Generally speaking, it might also be a good idea to test whether libc++ even works on top of LLVM's on libc.

libcxx/test/libcxx/thread/thread.mutex/version.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-threads
+
 // <mutex>
 
 #include <mutex>
 
 #include "test_macros.h"
 
 #ifndef _LIBCPP_VERSION
 #error _LIBCPP_VERSION not defined
 #endif
 
 int main(int, char**)
 {
 
   return 0;
 }

libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable.compile.pass.cpp

 #include <concepts>
 
 #include <array>
 #include <deque>
 #include <forward_list>
 #include <list>
 #include <map>
 #include <memory>
-#include <mutex>
 #include <optional>
 #include <set>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
+#ifndef _LIBCPP_HAS_NO_THREADS
+#   include <mutex>
+#endif
+
 #include "compare_types.h"
 
 namespace fundamentals {
 static_assert(std::equality_comparable<int>);
 static_assert(std::equality_comparable<double>);
 static_assert(std::equality_comparable<void*>);
 static_assert(std::equality_comparable<char*>);
 static_assert(std::equality_comparable<char const*>);

libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp

 #include <concepts>
 
 #include <array>
 #include <deque>
 #include <forward_list>
 #include <list>
 #include <map>
 #include <memory>
-#include <mutex>
 #include <optional>
 #include <set>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
+#ifndef _LIBCPP_HAS_NO_THREADS
+#   include <mutex>
+#endif
+
 #include "compare_types.h"
 
 template <class T, class U>
 constexpr bool check_equality_comparable_with() {
   constexpr bool result = std::equality_comparable_with<T, U>;
   static_assert(std::equality_comparable_with<U, T> == result);
   static_assert(std::equality_comparable_with<T, U const> == result);
   static_assert(std::equality_comparable_with<T const, U const> == result);

libcxx/test/std/concepts/concepts.lang/concept.assignable/assignable_from.compile.pass.cpp

 
 #include <concepts>
 
 #include <deque>
 #include <forward_list>
 #include <list>
 #include <map>
 #include <memory>
-#include <mutex>
 #include <optional>
 #include <string>
 #include <string_view>
 #include <unordered_map>
 #include <vector>
 
+#ifndef _LIBCPP_HAS_NO_THREADS
+#   include <mutex>
+#endif
+
 #include "../support/allocators.h"
 
 // Note: is_lvalue_reference is checked in all ModelsAssignableFrom calls.
 template <typename T1, typename T2>
 constexpr void NeverAssignableFrom() {
   static_assert(!std::assignable_from<T1, T2>);
   static_assert(!std::assignable_from<T1, const T2>);
   static_assert(!std::assignable_from<T1, T2&>);

libcxx/test/std/concepts/concepts.object/movable.compile.pass.cpp

 // concept movable = see below;
 
 #include <concepts>
 
 #include <deque>
 #include <forward_list>
 #include <list>
 #include <map>
-#include <mutex>
 #include <optional>
 #include <unordered_map>
 #include <vector>
 
+#ifndef _LIBCPP_HAS_NO_THREADS
+#   include <mutex>
+#endif
+
 #include "type_classification/moveconstructible.h"
 #include "type_classification/movable.h"
 
 // Movable types
 static_assert(std::movable<int>);
 static_assert(std::movable<int volatile>);
 static_assert(std::movable<int*>);
 static_assert(std::movable<int const*>);

libcxx/test/std/language.support/support.limits/support.limits.general/mutex.version.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // WARNING: This test was generated by generate_feature_test_macro_components.py
 // and should not be edited manually.
 //
 // clang-format off
 
+// UNSUPPORTED: libcpp-has-no-threads
+
 // <mutex>
 
 // Test the feature test macros defined by <mutex>
 
 /*  Constant                 Value
     __cpp_lib_scoped_lock    201703L [C++17]
 */
 

libcxx/test/std/thread/thread.mutex/thread.once/thread.once.callonce/call_once.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
-//
+
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <mutex>
 
 // struct once_flag;
 
 // template<class Callable, class ...Args>
 //   void call_once(once_flag& flag, Callable&& func, Args&&... args);

libcxx/test/std/thread/thread.mutex/thread.once/thread.once.callonce/race.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
-//
+
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <mutex>
 
 // struct once_flag;
 
 // template<class Callable, class ...Args>
 //   void call_once(once_flag& flag, Callable&& func, Args&&... args);

libcxx/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/assign.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-threads
+
 // <mutex>
 
 // struct once_flag;
 
 // once_flag& operator=(const once_flag&) = delete;
 
 #include <mutex>
 
 int main(int, char**)
 {
     std::once_flag f;
     std::once_flag f2;
     f2 = f;
 
   return 0;
 }

libcxx/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/copy.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-threads
+
 // <mutex>
 
 // struct once_flag;
 
 // once_flag(const once_flag&) = delete;
 
 #include <mutex>
 
 int main(int, char**)
 {
     std::once_flag f;
     std::once_flag f2(f);
 
   return 0;
 }

libcxx/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-threads
+
 // <mutex>
 
 // struct once_flag;
 
 // constexpr once_flag() noexcept;
 
 #include <mutex>
 #include "test_macros.h"

libcxx/utils/generate_feature_test_macro_components.py

 assert feature_test_macros == sorted(feature_test_macros, key=lambda tc: tc["name"])
 assert all(tc["headers"] == sorted(tc["headers"]) for tc in feature_test_macros)
 assert all(("libcxx_guard" in tc) == ("test_suite_guard" in tc) for tc in feature_test_macros)
 assert all(all(key in ["name", "values", "headers", "libcxx_guard", "test_suite_guard", "unimplemented"] for key in tc.keys()) for tc in feature_test_macros)
 
 # Map from each header to the Lit annotations that should be used for
 # tests that include that header.
 #
-# For example, when threads are not supported, any feature-test-macro test
-# that includes <thread> should be marked as UNSUPPORTED, because including
-# <thread> is a hard error in that case.
+# For example, when threads are not supported, any test that includes
+# <thread> should be marked as UNSUPPORTED, because including <thread>
+# is a hard error in that case.
 lit_markup = {
   "barrier": ["UNSUPPORTED: libcpp-has-no-threads"],
   "filesystem": ["UNSUPPORTED: libcpp-has-no-filesystem-library"],
   "format": ["UNSUPPORTED: libcpp-has-no-incomplete-format"],
   "iomanip": ["UNSUPPORTED: libcpp-has-no-localization"],
+  "ios": ["UNSUPPORTED: libcpp-has-no-localization"],
+  "iostream": ["UNSUPPORTED: libcpp-has-no-localization"],
   "istream": ["UNSUPPORTED: libcpp-has-no-localization"],
   "latch": ["UNSUPPORTED: libcpp-has-no-threads"],
   "locale": ["UNSUPPORTED: libcpp-has-no-localization"],
+  "mutex": ["UNSUPPORTED: libcpp-has-no-threads"],
   "ostream": ["UNSUPPORTED: libcpp-has-no-localization"],
   "ranges": ["UNSUPPORTED: libcpp-has-no-incomplete-ranges"],
   "regex": ["UNSUPPORTED: libcpp-has-no-localization"],
   "semaphore": ["UNSUPPORTED: libcpp-has-no-threads"],
   "shared_mutex": ["UNSUPPORTED: libcpp-has-no-threads"],
-  "thread": ["UNSUPPORTED: libcpp-has-no-threads"],
+  "thread": ["UNSUPPORTED: libcpp-has-no-threads"]
 }
 
 def get_std_dialects():
   std_dialects = ['c++14', 'c++17', 'c++20', 'c++2b']
   return list(std_dialects)
 
 def get_first_std(d):
     for s in get_std_dialects():

libcxx/utils/generate_header_inclusion_tests.py

new_in_version = {
     "variant": "17",
 }
 
 assert all(v == sorted(v) for k, v in mandatory_inclusions.items())
 
 # Map from each header to the Lit annotations that should be used for
 # tests that include that header.
 #
-# For example, when threads are not supported, any test
-# that includes <thread> should be marked as UNSUPPORTED, because including
-# <thread> is a hard error in that case.
+# For example, when threads are not supported, any test that includes
+# <thread> should be marked as UNSUPPORTED, because including <thread>
+# is a hard error in that case.
 lit_markup = {
   "barrier": ["UNSUPPORTED: libcpp-has-no-threads"],
   "filesystem": ["UNSUPPORTED: libcpp-has-no-filesystem-library"],
   "format": ["UNSUPPORTED: libcpp-has-no-incomplete-format"],
   "iomanip": ["UNSUPPORTED: libcpp-has-no-localization"],
   "ios": ["UNSUPPORTED: libcpp-has-no-localization"],
   "iostream": ["UNSUPPORTED: libcpp-has-no-localization"],
   "istream": ["UNSUPPORTED: libcpp-has-no-localization"],
   "latch": ["UNSUPPORTED: libcpp-has-no-threads"],
   "locale": ["UNSUPPORTED: libcpp-has-no-localization"],
+  "mutex": ["UNSUPPORTED: libcpp-has-no-threads"],
   "ostream": ["UNSUPPORTED: libcpp-has-no-localization"],
   "ranges": ["UNSUPPORTED: libcpp-has-no-incomplete-ranges"],
   "regex": ["UNSUPPORTED: libcpp-has-no-localization"],
   "semaphore": ["UNSUPPORTED: libcpp-has-no-threads"],
   "shared_mutex": ["UNSUPPORTED: libcpp-has-no-threads"],
-  "thread": ["UNSUPPORTED: libcpp-has-no-threads"],
+  "thread": ["UNSUPPORTED: libcpp-has-no-threads"]
 }
 
 
 def get_std_ver_test(includee):
     v = new_in_version.get(includee, "03")
     if v == "03":
         return ''
     versions = ["03", "11", "14", "17", "20"]