[libc++][C++20 modules] Tests no threading build.

[Mordante]

Summary

Depends on D158330

libcxx/cmake/caches/Generic-no-threads.cmake

+set(LIBCXX_ENABLE_STD_MODULES ON CACHE BOOL "") # TODO MODULES Remove when enabled automatically.
 set(LIBCXX_ENABLE_THREADS OFF CACHE BOOL "")
 set(LIBCXXABI_ENABLE_THREADS OFF CACHE BOOL "")
 set(LIBCXX_ENABLE_MONOTONIC_CLOCK OFF CACHE BOOL "")

libcxx/docs/Modules.rst

 
  * Building BMIs
  * Running tests using the ``std`` module
  * Using the ``std`` module in external projects
  * The following "parts disabled" configuration options are supported
 
    * ``LIBCXX_ENABLE_LOCALIZATION``
    * ``LIBCXX_ENABLE_WIDE_CHARACTERS``
+   * ``LIBCXX_ENABLE_THREADS``
 
 Some of the current limitations
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
  * There is no official build system support, libc++ has experimental CMake support
  * Requires CMake 3.26 for C++23 support
  * Requires CMake 3.27 for C++26 support
  * Requires Ninja 1.11

libcxx/modules/CMakeLists.txt.in

macro(compile_define_if_not condition def)
   endif()
 endmacro()
 macro(compile_define_if condition def)
   if (${condition})
     target_compile_definitions(std PRIVATE ${def})
   endif()
 endmacro()
 
-if(NOT @LIBCXX_ENABLE_THREADS@ OR NOT @LIBCXXABI_ENABLE_THREADS@ OR NOT @LIBCXX_ENABLE_MONOTONIC_CLOCK@)
-  message(FATAL_ERROR "Modules without thread support is not yet implemented.")
-endif()
 if(NOT @LIBCXX_ENABLE_FILESYSTEM@)
   message(FATAL_ERROR "Modules without filesystem support is not yet implemented.")
 endif()
 if(NOT @LIBCXX_ENABLE_RANDOM_DEVICE@)
   message(FATAL_ERROR "Modules without randome device support is not yet implemented.")
 endif()
 if(NOT @LIBCXX_ENABLE_UNICODE@)
   message(FATAL_ERROR "Modules without Unicode support is not yet implemented.")

libcxx/modules/std/barrier.inc

 // -*- 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
 //
 //===----------------------------------------------------------------------===//
 
 export namespace std {
+#ifndef _LIBCPP_HAS_NO_THREADS
   using std::barrier;
+#endif // _LIBCPP_HAS_NO_THREADS
 } // namespace std

libcxx/modules/std/chrono.inc

#if 0
     using std::chrono::gps_seconds;
     using std::chrono::gps_time;
 #endif
     // [time.clock.file], type file_clock
     using std::chrono::file_clock;
 
     using std::chrono::file_time;
 
+#ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK
     // [time.clock.steady], class steady_clock
     using std::chrono::steady_clock;
+#endif
 
     // [time.clock.hires], class high_resolution_clock
     using std::chrono::high_resolution_clock;
 
     // [time.clock.local], local time
     using std::chrono::local_days;
     using std::chrono::local_seconds;
     using std::chrono::local_t;

libcxx/modules/std/condition_variable.inc

 // -*- 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
 //
 //===----------------------------------------------------------------------===//
 
 export namespace std {
-
+#ifndef _LIBCPP_HAS_NO_THREADS
   // [thread.condition.condvar], class condition_variable
   using std::condition_variable;
   // [thread.condition.condvarany], class condition_variable_any
   using std::condition_variable_any;
 
   // [thread.condition.nonmember], non-member functions
   using std::notify_all_at_thread_exit;
 
   using std::cv_status;
-
+#endif // _LIBCPP_HAS_NO_THREADS
 } // namespace std

libcxx/modules/std/future.inc

 // -*- 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
 //
 //===----------------------------------------------------------------------===//
 
 export namespace std {
+#ifndef _LIBCPP_HAS_NO_THREADS
   using std::future_errc;
   using std::future_status;
   using std::launch;
 
   // launch is a bitmask type.
   // [bitmask.types] specified operators
   using std::operator&;
   using std::operator&=;
#ifndef _LIBCPP_HAS_NO_THREADS
   // [futures.shared.future], class template shared_future
   using std::shared_future;
 
   // [futures.task], class template packaged_task
   using std::packaged_task;
 
   // [futures.async], function template async
   using std::async;
+#endif // _LIBCPP_HAS_NO_THREADS
 } // namespace std

libcxx/modules/std/latch.inc

 // -*- 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
 //
 //===----------------------------------------------------------------------===//
 
 export namespace std {
+#ifndef _LIBCPP_HAS_NO_THREADS
   using std::latch;
+#endif // _LIBCPP_HAS_NO_THREADS
 } // namespace std

libcxx/modules/std/memory.inc

export namespace std {
   //  using std::out_ptr;
 
   // [inout.ptr.t], class template inout_ptr_t
   //  using std::inout_ptr_t;
 
   // [inout.ptr], function template inout_ptr
   //  using std::inout_ptr;
 
+#ifndef _LIBCPP_HAS_NO_THREADS
   // [depr.util.smartptr.shared.atomic]
   using std::atomic_is_lock_free;
 
   using std::atomic_load;
   using std::atomic_load_explicit;
 
   using std::atomic_store;
   using std::atomic_store_explicit;
 
   using std::atomic_exchange;
   using std::atomic_exchange_explicit;
 
   using std::atomic_compare_exchange_strong;
   using std::atomic_compare_exchange_strong_explicit;
   using std::atomic_compare_exchange_weak;
   using std::atomic_compare_exchange_weak_explicit;
+#endif // _LIBCPP_HAS_NO_THREADS
 } // namespace std

libcxx/modules/std/mutex.inc

 // -*- 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
 //
 //===----------------------------------------------------------------------===//
 
 export namespace std {
+#ifndef _LIBCPP_HAS_NO_THREADS
   // [thread.mutex.class], class mutex
   using std::mutex;
   // [thread.mutex.recursive], class recursive_mutex
   using std::recursive_mutex;
   // [thread.timedmutex.class] class timed_mutex
   using std::timed_mutex;
   // [thread.timedmutex.recursive], class recursive_timed_mutex
   using std::recursive_timed_mutex;
#ifndef _LIBCPP_HAS_NO_THREADS
   using std::scoped_lock;
   using std::unique_lock;
 
   using std::swap;
 
   // [thread.lock.algorithm], generic locking algorithms
   using std::lock;
   using std::try_lock;
+#endif // _LIBCPP_HAS_NO_THREADS
 
   using std::once_flag;
 
   using std::call_once;
 } // namespace std

libcxx/modules/std/semaphore.inc

 // -*- 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
 //
 //===----------------------------------------------------------------------===//
 
 export namespace std {
+#ifndef _LIBCPP_HAS_NO_THREADS
   // [thread.sema.cnt], class template counting_semaphore
   using std::counting_semaphore;
 
   using std::binary_semaphore;
+#endif // _LIBCPP_HAS_NO_THREADS
 } // namespace std

libcxx/modules/std/shared_mutex.inc

 // -*- 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
 //
 //===----------------------------------------------------------------------===//
 
 export namespace std {
+#ifndef _LIBCPP_HAS_NO_THREADS
   // [thread.sharedmutex.class], class shared_­mutex
   using std::shared_mutex;
   // [thread.sharedtimedmutex.class], class shared_­timed_­mutex
   using std::shared_timed_mutex;
   // [thread.lock.shared], class template shared_­lock
   using std::shared_lock;
   using std::swap;
+#endif // _LIBCPP_HAS_NO_THREADS
 } // namespace std

libcxx/modules/std/stop_token.inc

 // -*- 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
 //
 //===----------------------------------------------------------------------===//
 
 export namespace std {
+#ifndef _LIBCPP_HAS_NO_THREADS
   // [stoptoken], class stop_­token
   using std::stop_token;
 
   // [stopsource], class stop_­source
   using std::stop_source;
 
   // no-shared-stop-state indicator
   using std::nostopstate;
   using std::nostopstate_t;
 
   // [stopcallback], class template stop_­callback
   using std::stop_callback;
+#endif // _LIBCPP_HAS_NO_THREADS
 } // namespace std

libcxx/modules/std/thread.inc

 // -*- 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
 //
 //===----------------------------------------------------------------------===//
 
 export namespace std {
+#ifndef _LIBCPP_HAS_NO_THREADS
   // [thread.thread.class], class thread
   using std::thread;
 
   using std::swap;
 
   // [thread.jthread.class], class jthread
   // using std::jthread;
 
   // [thread.thread.this], namespace this_thread
   namespace this_thread {
     using std::this_thread::get_id;
 
     using std::this_thread::sleep_for;
     using std::this_thread::sleep_until;
     using std::this_thread::yield;
   } // namespace this_thread
 
   // [thread.thread.id]
   using std::operator==;
   using std::operator<=>;
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#  ifndef _LIBCPP_HAS_NO_LOCALIZATION
   using std::operator<<;
-#endif // _LIBCPP_HAS_NO_LOCALIZATION
+#  endif // _LIBCPP_HAS_NO_LOCALIZATION
 
   using std::formatter;
 
   using std::hash;
+#endif // _LIBCPP_HAS_NO_THREADS
 } // namespace std

libcxx/utils/ci/buildkite-pipeline.yml

steps:
   - group: "Parts disabled"
     steps:
     - label: "No threads"
       command: "libcxx/utils/ci/run-buildbot generic-no-threads"
       artifact_paths:
         - "**/test-results.xml"
         - "**/*.abilist"
       env:
-          CC: "clang-${LLVM_HEAD_VERSION}"
-          CXX: "clang++-${LLVM_HEAD_VERSION}"
+          # Note: Modules require and absolute path for clang-scan-deps
+          # https://github.com/llvm/llvm-project/issues/61006
+          CC: "/usr/lib/llvm-${LLVM_HEAD_VERSION}/bin/clang"
+          CXX: "/usr/lib/llvm-${LLVM_HEAD_VERSION}/bin/clang++"
+          CMAKE: "/opt/bin/cmake"
           ENABLE_CLANG_TIDY: "On"
       agents:
         queue: "libcxx-builders"
         os: "linux"
       retry:
         automatic:
           - exit_status: -1  # Agent was lost
             limit: 2