[native] Replace the AndroidSystem path statics with a POD buffer (#12552)

Part of #12533 (drop the `libc++` dependency), stacked on #12551.

`AndroidSystem` kept five of its members in `std::string` / `std::array<std::string, 1>`: `primary_override_dir`, `native_libraries_dir`, `app_code_cache_dir`, `single_app_lib_directory` and `override_dirs`.

Because they are `inline static` with dynamic initialization, the compiler emits a guard variable **and** an `atexit` registration for them in *every* translation unit that includes `android-system.hh` — even in ones that never touch them. `logger.cc`, `internal-pinvokes-clr.cc`, `internal-pinvokes-shared.cc` and `android-system-shared.cc` each paid four libc++ references (`~basic_string`, `operator delete`, `__cxa_guard_acquire`, `__cxa_guard_release`) without using a single one of these directories:

```
$ llvm-nm --undefined-only logger.cc.o | llvm-cxxfilt
std::__ndk1::basic_string<...>::~basic_string()
operator delete(void*)
__cxa_guard_acquire
__cxa_guard_release

$ llvm-objdump -r logger.cc.o | grep _ZGV | llvm-cxxfilt
guard variable for xamarin::android::AndroidSystem::override_dirs
guard variable for xamarin::android::AndroidSystem::app_code_cache_dir
guard variable for xamarin::android::AndroidSystem::native_libraries_dir
guard variable for xamarin::android::AndroidSystem::primary_override_dir
guard variable for xamarin::android::AndroidSystem::single_app_lib_directory
```

## What changed

All five become plain pointers. The three path members are `const char*` initialized to `""` and assigned once, early during startup, with a copy made by a new `Util::duplicate_string()` helper that aborts if the allocation fails. Pointers to a string literal are **constant-initialized**, so neither a guard variable nor an `atexit` registration is emitted.

The two directory arrays become plain `const char*` arrays whose entries are `malloc`ed, which also drops an `operator new[]` from the non-split-APK path.

Since there is no longer a fixed-size buffer anywhere, there is also no hard limit on the path length and no abort when it is exceeded — which is what NativeAOT's `char[SENSIBLE_PATH_MAX]` `primary_override_dir` used to do. That lets `primary_override_dir` be shared by all three hosts, removing three `#if defined (XA_HOST_NATIVEAOT)` blocks and `determine_primary_override_dir()` entirely.

## Results

Undefined libc++ references in the three CoreCLR archives — **58 → 31**:

| object | before | after |
|---|---:|---:|
| `assembly-store.cc.o` | 13 | 11 |
| `host.cc.o` | 11 | 11 |
| `android-system.cc.o` | 11 | 5 |
| `timing-internal.cc.o` | 5 | 2 |
| `logger.cc.o` | 4 | **0** |
| `internal-pinvokes-shared.cc.o` | 4 | **0** |
| `internal-pinvokes-clr.cc.o` | 4 | **0** |
| `android-system-shared.cc.o` | 4 | **0** |
| `typemap.cc.o` | 2 | 2 |

Every `__cxa_guard_*` reference coming from this header is gone; the only ones left are `host.cc`'s own function-local statics.

`libnet-android.release.so`: **539,464 → 536,368 bytes (−3,096)**.

The DEBUG-only code paths were compile-checked separately (there is no Debug ninja directory) and go from 12 to 7 references; `llvm-nm` confirms `add_system_property`, `find_bundled_property` and `setup_environment_from_override_file` are genuinely emitted rather than silently `#if`'d out.

CoreCLR, NativeAOT and MonoVM all build clean.

Author: simonrozsival

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

@@ -311,8 +311,8 @@ namespace {
 				return;
 			}
 
-			std::string const& code_cache_dir = AndroidSystem::get_app_code_cache_dir ();
-			if (code_cache_dir.empty ()) {
+			const char *code_cache_dir = AndroidSystem::get_app_code_cache_dir ();
+			if (*code_cache_dir == '\0') {
 				return;
 			}
 

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

@@ -36,9 +36,9 @@ auto FastDevAssemblies::open_assembly (std::string_view const& name, int64_t &si
 		return nullptr;
 	}
 
-	std::string const& override_dir_path = AndroidSystem::get_primary_override_dir ();
+	const char *override_dir_path = AndroidSystem::get_primary_override_dir ();
 	if (!Util::dir_exists (override_dir_path)) [[unlikely]] {
-		log_debugf (LOG_ASSEMBLY, "Override directory '%s' does not exist", override_dir_path.c_str ());
+		log_debugf (LOG_ASSEMBLY, "Override directory '%s' does not exist", override_dir_path);
 		return nullptr;
 	}
 
@@ -47,9 +47,9 @@ auto FastDevAssemblies::open_assembly (std::string_view const& name, int64_t &si
 	if (override_dir_fd < 0) [[unlikely]] {
 		lock_guard dir_lock { override_dir_lock };
 		if (override_dir_fd < 0) [[likely]] {
-			override_dir = opendir (override_dir_path.c_str ());
+			override_dir = opendir (override_dir_path);
 			if (override_dir == nullptr) [[unlikely]] {
-				log_warnf (LOG_ASSEMBLY, "Failed to open override dir '%s'. %s", override_dir_path.c_str (), strerror (errno));
+				log_warnf (LOG_ASSEMBLY, "Failed to open override dir '%s'. %s", override_dir_path, strerror (errno));
 				return nullptr;
 			}
 			override_dir_fd = dirfd (override_dir);
@@ -60,7 +60,7 @@ auto FastDevAssemblies::open_assembly (std::string_view const& name, int64_t &si
 		LOG_ASSEMBLY,
 		"Attempting to load FastDev assembly '%.*s' from override directory '%s'",
 		static_cast<int>(name.length ()), name.data (),
-		override_dir_path.c_str ()
+		override_dir_path
 	);
 
 	if (!Util::file_exists (override_dir_fd, name)) {
@@ -133,14 +133,14 @@ auto FastDevAssemblies::build_tpa_list (std::string &tpa_list) noexcept -> bool
 {
 	tpa_list.clear ();
 
-	std::string const& override_dir_path = AndroidSystem::get_primary_override_dir ();
+	const char *override_dir_path = AndroidSystem::get_primary_override_dir ();
 	if (!Util::dir_exists (override_dir_path)) {
 		return false;
 	}
 
-	DIR *dir = opendir (override_dir_path.c_str ());
+	DIR *dir = opendir (override_dir_path);
 	if (dir == nullptr) {
-		log_warnf (LOG_ASSEMBLY, "FastDev: failed to open override dir '%s'. %s", override_dir_path.c_str (), std::strerror (errno));
+		log_warnf (LOG_ASSEMBLY, "FastDev: failed to open override dir '%s'. %s", override_dir_path, std::strerror (errno));
 		return false;
 	}
 
@@ -183,7 +183,7 @@ auto FastDevAssemblies::build_tpa_list (std::string &tpa_list) noexcept -> bool
 		LOG_ASSEMBLY,
 		"FastDev: built TPA list with %zu assemblies from '%s' (corelib=%s, r2r=%s)",
 		count,
-		override_dir_path.c_str (),
+		override_dir_path,
 		found_corelib ? "true" : "false",
 		found_r2r ? "true" : "false"
 	);

src/native/clr/host/host.cc

@@ -91,16 +91,16 @@ bool Host::clr_external_assembly_probe (const char *path, void **data_start, int
 [[gnu::always_inline]]
 void Host::scan_filesystem_for_assemblies_and_libraries () noexcept
 {
-	std::string const& native_lib_dir = AndroidSystem::get_native_libraries_dir ();
-	log_debugf (LOG_ASSEMBLY, "Looking for assemblies in '%s'", native_lib_dir.c_str ());
+	const char *native_lib_dir = AndroidSystem::get_native_libraries_dir ();
+	log_debugf (LOG_ASSEMBLY, "Looking for assemblies in '%s'", native_lib_dir);
 
-	DIR *lib_dir = opendir (native_lib_dir.c_str ());
+	DIR *lib_dir = opendir (native_lib_dir);
 	if (lib_dir == nullptr) [[unlikely]] {
 		Helpers::abort_applicationf (
 			LOG_ASSEMBLY,
 			std::source_location::current (),
 			"Unable to open native library directory '%s'. %s",
-			native_lib_dir.c_str (),
+			native_lib_dir,
 			std::strerror (errno)
 		);
 	}
@@ -111,7 +111,7 @@ void Host::scan_filesystem_for_assemblies_and_libraries () noexcept
 			LOG_ASSEMBLY,
 			std::source_location::current (),
 			"Unable to obtain file descriptor for opened directory '%s'. %s",
-			native_lib_dir.c_str (),
+			native_lib_dir,
 			std::strerror (errno)
 		);
 	}
@@ -121,7 +121,7 @@ void Host::scan_filesystem_for_assemblies_and_libraries () noexcept
 		dirent *cur = readdir (lib_dir);
 		if (cur == nullptr) {
 			if (errno != 0) {
-				log_warnf (LOG_ASSEMBLY, "Failed to open a directory entry from '%s': %s", native_lib_dir.c_str (), std::strerror (errno));
+				log_warnf (LOG_ASSEMBLY, "Failed to open a directory entry from '%s': %s", native_lib_dir, std::strerror (errno));
 				continue; // No harm, keep going
 			}
 			break; // we're done
@@ -138,7 +138,7 @@ void Host::scan_filesystem_for_assemblies_and_libraries () noexcept
 				continue;
 			}
 
-			log_debugf (LOG_ASSEMBLY, "Found assembly store in '%s/%s'", native_lib_dir.c_str (), Constants::assembly_store_file_name.data ());
+			log_debugf (LOG_ASSEMBLY, "Found assembly store in '%s/%s'", native_lib_dir, Constants::assembly_store_file_name.data ());
 
 			std::string store_path = native_lib_dir;
 			store_path.append ("/"sv);
@@ -339,7 +339,7 @@ void Host::Java_mono_android_Runtime_initInternal (
 	AndroidSystem::set_app_code_cache_dir (applicationDirs[Constants::APP_DIRS_CODE_CACHE_DIR_INDEX]);
 	AndroidSystem::create_update_dir (AndroidSystem::get_primary_override_dir ());
 	AndroidSystem::setup_environment ();
-	Logger::init_reference_logging (AndroidSystem::get_primary_override_dir ().c_str ());
+	Logger::init_reference_logging (AndroidSystem::get_primary_override_dir ());
 
 	jstring_array_wrapper runtimeApks (env, runtimeApksJava);
 	AndroidSystem::setup_app_library_directories (runtimeApks, applicationDirs, haveSplitApks);

src/native/clr/include/host/host-environment.hh

@@ -92,7 +92,7 @@ namespace xamarin::android {
 		[[gnu::flatten, gnu::always_inline]]
 		static void create_xdg_directory (jstring_wrapper &home, std::string_view const& relative_path, std::string_view const& environment_variable_name) noexcept
 		{
-			std::string_view home_path = home.get_string_view ();
+			const char *home_path = home.get_cstr ();
 			char stack_buffer [Util::LocalPathBufferSize];
 			ssize_t result = Util::format_joined_path (stack_buffer, sizeof (stack_buffer), home_path, relative_path);
 			abort_unless (result >= 0, "XDG directory path is too long");

src/native/clr/include/runtime-base/android-system.hh

@@ -4,7 +4,6 @@
 #include <cstdio>
 #include <limits>
 #include <span>
-#include <string>
 #include <string_view>
 
 #include "../constants.hh"
@@ -32,11 +31,11 @@ namespace xamarin::android {
 #if !defined (XA_HOST_NATIVEAOT)
 		// This optimizes things a little bit. The array is allocated at build time, so we pay no cost for its
 		// allocation and at run time it allows us to skip dynamic memory allocation.
-		inline static std::array<std::string, 1> single_app_lib_directory{};
-		inline static std::span<std::string> app_lib_directories;
+		inline static const char *single_app_lib_directory [1] { "" };
+		inline static std::span<const char*> app_lib_directories;
 
 		// TODO: override dirs not implemented
-		inline static std::array<std::string, 1> override_dirs{};
+		inline static const char *override_dirs [1] { "" };
 
 		static constexpr std::array<std::string_view, 7> android_abi_names {
 			std::string_view { "unknown" },     // CPU_KIND_UNKNOWN
@@ -73,45 +72,47 @@ namespace xamarin::android {
 			running_in_emulator = yesno;
 		}
 
-#if defined (XA_HOST_NATIVEAOT)
 		static auto get_primary_override_dir () noexcept -> const char*
 		{
 			return primary_override_dir;
 		}
-#else
-		static auto get_primary_override_dir () noexcept -> std::string const&
-		{
-			return primary_override_dir;
-		}
-#endif
 
 		static void set_primary_override_dir (jstring_wrapper& home) noexcept
 		{
-#if defined (XA_HOST_NATIVEAOT)
-			ssize_t result = format_primary_override_dir (home, primary_override_dir, sizeof (primary_override_dir));
-			abort_unless (result >= 0, "Primary override directory path is too long");
-#else
-			primary_override_dir = determine_primary_override_dir (home);
-#endif
+			char stack_buffer [Constants::SENSIBLE_PATH_MAX];
+			char *path = stack_buffer;
+			ssize_t result = format_primary_override_dir (home, path, sizeof (stack_buffer));
+			if (result < 0) {
+				size_t required_capacity = static_cast<size_t>(-result);
+				path = static_cast<char*> (std::malloc (required_capacity));
+				abort_unless (path != nullptr, "Failed to allocate primary override directory path");
+				result = format_primary_override_dir (home, path, required_capacity);
+			}
+			abort_unless (result >= 0, "Failed to format primary override directory path using the required capacity");
+
+			primary_override_dir = Util::duplicate_string (path);
+			if (path != stack_buffer) {
+				std::free (path);
+			}
 		}
 
 #if !defined (XA_HOST_NATIVEAOT)
-		static auto get_app_code_cache_dir () noexcept -> std::string const&
+		static auto get_app_code_cache_dir () noexcept -> const char*
 		{
 			return app_code_cache_dir;
 		}
 
 		static void set_app_code_cache_dir (jstring_wrapper& code_cache_dir) noexcept
 		{
-			app_code_cache_dir.assign (code_cache_dir.get_cstr ());
+			app_code_cache_dir = Util::duplicate_string (code_cache_dir.get_cstr ());
 		}
 
-		static auto get_native_libraries_dir () noexcept -> std::string const&
+		static auto get_native_libraries_dir () noexcept -> const char*
 		{
 			return native_libraries_dir;
 		}
 
-		static void create_update_dir (std::string const& override_dir) noexcept
+		static void create_update_dir (const char *override_dir) noexcept
 		{
 			if constexpr (Constants::is_release_build) {
 				/*
@@ -129,8 +130,8 @@ namespace xamarin::android {
 				}
 			}
 
-			log_debugf (LOG_DEFAULT, "Creating public update directory: `%s`", override_dir.c_str ());
-			Util::create_public_directory (override_dir.c_str ());
+			log_debugf (LOG_DEFAULT, "Creating public update directory: `%s`", override_dir);
+			Util::create_public_directory (override_dir);
 		}
 #endif
 
@@ -158,9 +159,9 @@ namespace xamarin::android {
 		static auto load_dso_from_any_directories (std::string_view const& name, int dl_flags, bool is_jni) noexcept -> void*;
 
 	private:
-		static auto format_full_dso_path (std::string const& base_dir, std::string_view const& dso_path, char *buffer, size_t buffer_size) noexcept -> ssize_t;
+		static auto format_full_dso_path (const char *base_dir, std::string_view const& dso_path, char *buffer, size_t buffer_size) noexcept -> ssize_t;
 
-		static auto get_full_dso_path (std::string const& base_dir, std::string_view const& dso_path, char *stack_buffer, size_t stack_buffer_size) noexcept -> char*
+		static auto get_full_dso_path (const char *base_dir, std::string_view const& dso_path, char *stack_buffer, size_t stack_buffer_size) noexcept -> char*
 		{
 			ssize_t result = format_full_dso_path (base_dir, dso_path, stack_buffer, stack_buffer_size);
 			if (result >= 0) {
@@ -226,38 +227,18 @@ namespace xamarin::android {
 			return static_cast<ssize_t>(length);
 		}
 
-#if !defined (XA_HOST_NATIVEAOT)
-		static auto determine_primary_override_dir (jstring_wrapper &home) noexcept -> std::string
-		{
-			char stack_buffer [Constants::SENSIBLE_PATH_MAX];
-			size_t length;
-			char *name = Util::format_with_retry (
-				stack_buffer,
-				sizeof (stack_buffer),
-				[&home](char *buffer, size_t buffer_size) noexcept {
-					return format_primary_override_dir (home, buffer, buffer_size);
-				},
-				&length
-			);
-
-			std::string path { name, length };
-			if (name != stack_buffer) {
-				std::free (name);
-			}
-			return path;
-		}
-#endif
-
 	private:
 		static inline long max_gref_count = 0;
 		static inline bool running_in_emulator = false;
 		static inline bool embedded_dso_mode_enabled = false;
-#if defined (XA_HOST_NATIVEAOT)
-		static inline char primary_override_dir[Constants::SENSIBLE_PATH_MAX] {};
-#else
-		static inline std::string primary_override_dir;
-		static inline std::string native_libraries_dir;
-		static inline std::string app_code_cache_dir;
+		// These are set once, early during startup, and are read for as long as the process lives.
+		// They are plain pointers so that they are constant-initialized: a `std::string` here would
+		// make the compiler emit a guard variable and an `atexit` registration in every translation
+		// unit which includes this header.
+		static inline const char *primary_override_dir = "";
+#if !defined (XA_HOST_NATIVEAOT)
+		static inline const char *native_libraries_dir = "";
+		static inline const char *app_code_cache_dir = "";
 
 #if defined (DEBUG)
 		static inline BundledProperty *bundled_properties = nullptr;

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

@@ -41,6 +41,21 @@ namespace xamarin::android {
 	public:
 		static constexpr size_t LocalPathBufferSize = Constants::SENSIBLE_PATH_MAX;
 
+		// Returns a copy of `str` allocated with `malloc`, aborting the application if the
+		// allocation fails. Used for values which are set once, early during startup, and which
+		// then live for as long as the process does - the copies are never freed.
+		static auto duplicate_string (const char *str) noexcept -> char*
+		{
+			abort_unless (str != nullptr, "String to duplicate must not be null");
+
+			char *ret = strdup (str);
+			if (ret == nullptr) [[unlikely]] {
+				Helpers::abort_application (LOG_DEFAULT, "Unable to allocate memory for a string copy");
+			}
+
+			return ret;
+		}
+
 		static int create_directory (const char *pathname, mode_t mode);
 
 		static auto create_directory (std::string_view const& dir, mode_t mode) noexcept -> int
@@ -310,6 +325,22 @@ namespace xamarin::android {
 			return !path.empty () && path.contains ('/');
 		}
 
+		[[gnu::flatten, gnu::always_inline]]
+		static auto ends_with (const char *value, const char *suffix) noexcept -> bool
+		{
+			if (value == nullptr || suffix == nullptr) {
+				return false;
+			}
+
+			size_t value_length = strlen (value);
+			size_t suffix_length = strlen (suffix);
+			if (suffix_length > value_length) {
+				return false;
+			}
+
+			return memcmp (value + value_length - suffix_length, suffix, suffix_length) == 0;
+		}
+
 		// Returns the path length excluding NUL, or the negative required capacity including NUL.
 		static auto format_joined_path (char *buffer, size_t buffer_size, std::string_view first, std::string_view second) noexcept -> ssize_t
 		{