[native] Replace std::mutex with pthread_mutex_t in the CoreCLR host (#12541)

Part of #12533 (drop `libc++` from the CoreCLR host). Stacked on top of #12534.

`std::mutex` is a thin wrapper over `pthread_mutex_t`, but using it pulls `<mutex>` and out-of-line libc++ symbols into the native host. This PR stores `pthread_mutex_t` directly and provides a small CoreCLR RAII guard so locked scopes retain automatic unlock behavior without libc++.

### What

* Replace CoreCLR's `std::mutex` instances with `pthread_mutex_t`, initialized using `PTHREAD_MUTEX_INITIALIZER`.
* Add `xamarin::android::lock_guard` under the CoreCLR include tree. It takes `pthread_mutex_t&` and calls `pthread_mutex_lock` / `pthread_mutex_unlock`.
* Update CoreCLR's `StartupAwareLock` to take `pthread_mutex_t&` directly.
* Convert shared `Timing` to direct pthread calls and keep it explicitly non-copyable and non-movable.
* Leave `src/native/mono` unchanged; MonoVM retains its existing `mutex` and templated `lock_guard` implementation in `mono/shared/cppcompat.hh`.

`PTHREAD_MUTEX_INITIALIZER` keeps static instances constant-initialized, so this adds no thread-safe initialization guards. The CoreCLR guard is header-only and compiles down to direct pthread calls.

### Effect

This removes the last `#include <mutex>` in the repository:

| | files including `<mutex>` | `std::mutex` / `std::lock_guard` uses |
|---|---:|---:|
| before | 6 | 13 |
| after | **0** | **0** |

It also drops eight undefined libc++ references:

| symbol | before | after |
|---|---:|---:|
| `std::__ndk1::mutex::lock()` | 3 | 0 |
| `std::__ndk1::mutex::unlock()` | 3 | 0 |
| `std::__ndk1::mutex::~mutex()` | 2 | 0 |

| | refs | `__cxa_guard_*` |
|---|---:|---:|
| #12534 (base) | 55 | 10 |
| this PR | **47** | 10 |

The link-time `libc++` requirement only disappears when every cause reaches zero, so this is one of several prerequisites rather than a self-sufficient win. The remaining causes (`operator new`/`delete[]`, `__cxa_guard_*`, `std::string`, `__libcpp_verbose_abort`) are tracked in #12533.

### Verification

* CoreCLR, MonoVM and NativeAOT build clean.
* `fastdev-assemblies.cc` is `#if defined(DEBUG)` and was additionally compiled with `-DDEBUG`.
* The CoreCLR guard compiled with the runtime's no-C++-exceptions settings references only `pthread_mutex_lock` and `pthread_mutex_unlock`; it introduces no C++ exception-runtime or initialization-guard symbols.
* Real `libc++` references: **CoreCLR 55 → 47, NativeAOT 0**. The eight removed references are exactly the mutex members listed above.
* `__cxa_guard_*` undefined references remain at **10**, confirming that the static mutexes remain constant-initialized.

Author: simonrozsival

src/native/clr/host/assembly-store.cc

@@ -4,7 +4,6 @@
 #include <cstring>
 #include <deque>
 #include <memory>
-#include <mutex>
 #include <string>
 
 #include <dirent.h>
@@ -79,7 +78,7 @@ namespace {
 			Failed,
 		};
 
-		std::mutex                        state_lock;
+		pthread_mutex_t                   state_lock = PTHREAD_MUTEX_INITIALIZER;
 		std::deque<WriteRequest>          write_queue;
 		std::string                       cache_dir;
 		std::unique_ptr<uint8_t*[]>       tracking;
@@ -177,7 +176,7 @@ namespace {
 			while (true) {
 				WriteRequest request;
 				{
-					std::lock_guard lock (state_lock);
+					lock_guard lock (state_lock);
 					if (write_queue.empty ()) {
 						writer_running = false;
 						return nullptr;
@@ -192,7 +191,7 @@ namespace {
 				request.data.reset ();
 
 				{
-					std::lock_guard lock (state_lock);
+					lock_guard lock (state_lock);
 					queued_bytes -= request_size;
 					if (write_result == WriteResult::Failed) {
 						writes_enabled = false;
@@ -345,7 +344,7 @@ namespace {
 			}
 
 			{
-				std::lock_guard lock (state_lock);
+				lock_guard lock (state_lock);
 				writes_enabled = true;
 			}
 
@@ -426,7 +425,7 @@ namespace {
 			size_t bytes_queued = 0;
 			bool queue_full = false;
 			{
-				std::lock_guard lock (state_lock);
+				lock_guard lock (state_lock);
 				if (!writes_enabled) {
 					return;
 				}
@@ -463,7 +462,7 @@ namespace {
 
 			auto snapshot = std::unique_ptr<uint8_t[]> (new (std::nothrow) uint8_t[total]);
 			if (snapshot == nullptr) {
-				std::lock_guard lock (state_lock);
+				lock_guard lock (state_lock);
 				queued_bytes -= total;
 				return;
 			}
@@ -488,7 +487,7 @@ namespace {
 			};
 
 			{
-				std::lock_guard lock (state_lock);
+				lock_guard lock (state_lock);
 				if (!writes_enabled) {
 					queued_bytes -= total;
 					return;

src/native/clr/host/fastdev-assemblies.cc

@@ -45,7 +45,7 @@ auto FastDevAssemblies::open_assembly (std::string_view const& name, int64_t &si
 	// NOTE: override_dir will be kept open, we have no way of knowing when it will be no longer
 	//       needed
 	if (override_dir_fd < 0) [[unlikely]] {
-		std::lock_guard dir_lock { override_dir_lock };
+		lock_guard dir_lock { override_dir_lock };
 		if (override_dir_fd < 0) [[likely]] {
 			override_dir = opendir (override_dir_path.c_str ());
 			if (override_dir == nullptr) [[unlikely]] {

src/native/clr/include/host/assembly-store.hh

@@ -3,11 +3,11 @@
 #include <cstdint>
 #include <functional>
 #include <limits>
-#include <mutex>
 #include <string>
 #include <string_view>
 #include <tuple>
 
+#include <runtime-base/mutex.hh>
 #include <xamarin-app.hh>
 
 namespace xamarin::android {
@@ -36,6 +36,6 @@ namespace xamarin::android {
 		// CRC32 hash collisions in the store index. Built once when the store is mapped.
 		static inline std::string_view *assembly_store_names = nullptr;
 		static inline uint64_t assembly_store_content_id = 0;
-		static inline std::mutex  assembly_decompress_mutex {};
+		static inline pthread_mutex_t assembly_decompress_mutex = PTHREAD_MUTEX_INITIALIZER;
 	};
 }

src/native/clr/include/host/fastdev-assemblies.hh

@@ -3,10 +3,11 @@
 #include <dirent.h>
 
 #include <cstdint>
-#include <mutex>
 #include <string>
 #include <string_view>
 
+#include <runtime-base/mutex.hh>
+
 namespace xamarin::android {
 	class FastDevAssemblies
 	{
@@ -30,7 +31,7 @@ namespace xamarin::android {
 #if defined(DEBUG)
 		static inline DIR *override_dir = nullptr;
 		static inline int override_dir_fd = -1;
-		static inline std::mutex override_dir_lock {};
+		static inline pthread_mutex_t override_dir_lock = PTHREAD_MUTEX_INITIALIZER;
 		// Set by `build_tpa_list` when assemblies in the override directory are
 		// passed to CoreCLR via `TRUSTED_PLATFORM_ASSEMBLIES`. When true, the
 		// external assembly probe yields to TPA-based loading so that

src/native/clr/include/runtime-base/monodroid-dl.hh

@@ -1,12 +1,12 @@
 #pragma once
 
-#include <mutex>
 #include <string_view>
 
 #include <dlfcn.h>
 #include <android/dlext.h>
 
 #include <java-interop-dlfcn.h>
+#include <runtime-base/mutex.hh>
 
 #include "../xamarin-app.hh"
 
@@ -20,7 +20,7 @@ namespace xamarin::android
 {
 	class MonodroidDl
 	{
-		static inline std::mutex   dso_handle_write_lock;
+		static inline pthread_mutex_t dso_handle_write_lock = PTHREAD_MUTEX_INITIALIZER;
 
 		[[gnu::always_inline]]
 		static constexpr auto ascii_to_lower (char c) noexcept -> char

src/native/clr/include/runtime-base/mutex.hh

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <pthread.h>
+
+namespace xamarin::android
+{
+	// Scope-based locking without `std::lock_guard`, which would make the runtime depend on libc++.
+	// See https://github.com/dotnet/android/issues/12533
+	class lock_guard final
+	{
+	public:
+		explicit lock_guard (pthread_mutex_t &mutex) noexcept
+			: mutex (mutex)
+		{
+			pthread_mutex_lock (&mutex);
+		}
+
+		~lock_guard () noexcept
+		{
+			pthread_mutex_unlock (&mutex);
+		}
+
+		lock_guard (lock_guard const&) = delete;
+		lock_guard (lock_guard&&) = delete;
+
+		auto operator= (lock_guard const&) -> lock_guard& = delete;
+		auto operator= (lock_guard&&) -> lock_guard& = delete;
+
+	private:
+		pthread_mutex_t &mutex;
+	};
+}

src/native/clr/include/runtime-base/startup-aware-lock.hh

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <mutex>
+#include <runtime-base/mutex.hh>
 
 #include "monodroid-state.hh"
 
@@ -9,21 +9,21 @@ namespace xamarin::android
 	class StartupAwareLock final
 	{
 	public:
-		explicit StartupAwareLock (std::mutex &m)
+		explicit StartupAwareLock (pthread_mutex_t &m)
 			: lock (m)
 		{
 			if (MonodroidState::is_startup_in_progress ()) {
 				// During startup we run without threads, do nothing
 				return;
 			}
-			lock.lock ();
+			pthread_mutex_lock (&lock);
 			owns_lock = true;
 		}
 
 		~StartupAwareLock ()
 		{
 			if (owns_lock) {
-				lock.unlock ();
+				pthread_mutex_unlock (&lock);
 			}
 		}
 
@@ -33,7 +33,7 @@ namespace xamarin::android
 		StartupAwareLock& operator= (StartupAwareLock const&) = delete;
 
 	private:
-		std::mutex& lock;
+		pthread_mutex_t &lock;
 		bool owns_lock = false;
 	};
 }

src/native/common/include/runtime-base/timing.hh

@@ -1,9 +1,9 @@
 #pragma once
 
+#include <pthread.h>
 #include <sys/time.h>
 
 #include <chrono>
-#include <mutex>
 #include <vector>
 #include <string_view>
 
@@ -32,6 +32,11 @@ namespace xamarin::android
 			sequence_pool.resize (initial_pool_size);
 		}
 
+		Timing (Timing const&) = delete;
+		Timing (Timing&&) = delete;
+		Timing& operator= (Timing const&) = delete;
+		Timing& operator= (Timing&&) = delete;
+
 		static void info (managed_timing_sequence const *seq, const char *message)
 		{
 			do_log (LogLevel::Info, seq, message);
@@ -44,7 +49,7 @@ namespace xamarin::android
 
 		auto get_available_sequence () noexcept -> managed_timing_sequence*
 		{
-			std::lock_guard<std::mutex> lock (sequence_lock);
+			pthread_mutex_lock (&sequence_lock);
 
 			managed_timing_sequence *ret;
 			for (size_t i = 0uz; i < sequence_pool.size (); i++) {
@@ -55,11 +60,13 @@ namespace xamarin::android
 				ret = &sequence_pool[i];
 				ret->in_use = true;
 
+				pthread_mutex_unlock (&sequence_lock);
 				return ret;
 			}
 			ret = &sequence_pool.emplace_back ();
 			ret->in_use = true;
 
+			pthread_mutex_unlock (&sequence_lock);
 			return ret;
 		}
 
@@ -69,10 +76,11 @@ namespace xamarin::android
 				return;
 			}
 
-			std::lock_guard<std::mutex> lock (sequence_lock);
+			pthread_mutex_lock (&sequence_lock);
 			sequence->start = time_point::min ();
 			sequence->end = time_point::min ();
 			sequence->in_use = false;
+			pthread_mutex_unlock (&sequence_lock);
 		}
 
 	private:
@@ -98,6 +106,6 @@ namespace xamarin::android
 
 	private:
 		std::vector<managed_timing_sequence> sequence_pool;
-		std::mutex                sequence_lock;
+		pthread_mutex_t           sequence_lock = PTHREAD_MUTEX_INITIALIZER;
 	};
 }