Drop libc++ from Android NativeAOT linking

[simonrozsival]

Summary

This removes the Android NativeAOT app link-time dependency on libc++.

The branch now:

• removes the explicit NativeAOT libc++_static.a and libc++abi.a link inputs;
• removes libc++ packaging from the Android native runtime component list;
• keeps the final NativeAOT app link on the direct ld.lld/NativeLinker path;
• reduces NativeAOT-reachable host code that pulled in C++ runtime/STL symbols;
• adds NativeAOT-local C++ allocation/nothrow shims for the remaining runtime-pack allocation references;
• shares GC bridge processing between CoreCLR and NativeAOT without tsl::robin_map or other libc++-requiring containers;
• adds printf-style native logging helpers so call sites can avoid repeated snprintf boilerplate and skip formatting when logging is disabled.

Context

This is related to #9926 and the NDK r29 NativeAOT linking work.

The relevant background is that Android NativeAOT should avoid depending on libc++ instead of working around duplicate libunwind symbols or switching to shared libc++. Related references:

• [NativeAOT] Fix application linking with API level > 21 #10812 fixed NativeAOT linking with API levels above 21 by making sure the final link uses the correct Android API level/toolchain invocation.
• [NAOT][android] Application linking breaks with NDK r29 because of duplicated libunwind symbols runtime#121172 tracks the NDK r29 duplicate libunwind symbol failure and discusses removing the libc++ dependency from Android NativeAOT.
• [Android NDK] Make API level configurable runtime#124461 makes the NativeAOT Android API level configurable so runtime and app links use matching Android API levels.
• Remove libstdc++ dependency from NativeAOT runtime#76705 is prior art for removing a C++ standard-library dependency from NativeAOT.

GC bridge / Java peer shape history

The GC bridge sharing in this PR exposed one remaining runtime-specific difference: classic Mono/CoreCLR Java peers use mono.android.* and monodroidAddReference() / monodroidClearReferences(), while NativeAOT trimmable proxy objects use net.dot.jni.GCUserPeerable and jiAddManagedReference() / jiClearManagedReferences().

Brief history:

• Allow MonoGCBridgeSCC objects to have an empty User Peer list #154 is early GC bridge history for the classic mono.android.GCUserPeer temporary-peer model.
• Use a field for GC references #2435 documents the long-standing classic Java peer shape where Java Callable Wrappers keep managedReferences and expose monodroidAddReference() / monodroidClearReferences().
• [Mono.Android] Java.Interop Unification! #9640 completed Java.Interop unification for Mono.Android, but preserved compatibility with the existing Android peer/reference shape.
• Discussion: Ways to *actually* fix trimmer warnings around Type.GetType()? java-interop#1165 and [Java.Interop] Avoid Type.GetType() in ManagedPeer java-interop#1168 show why Java.Interop's Java-side ManagedPeer.registerNativeMembers() / string-based type lookup path was problematic for trimming and NativeAOT.
• [nativeaot] introduce Microsoft.Android.Runtime.NativeAOT.dll #9760 introduced Microsoft.Android.Runtime.NativeAOT.dll and moved NativeAOT Java runtime pieces from the sample into build-time generated sources.
• [CoreCLR] Implement GC bridge #10198 added the CoreCLR GC bridge and explicitly noted the implementation was CoreCLR-specific but could be reused for NativeAOT later.
• [native] NativeAOT runtime #10461 added the NativeAOT host and support for the CoreCLR GC bridge.
• [TrimmableTypeMap] Use trimmable Java proxy runtime sources #11271 added trimmable-specific Java proxy runtime sources, replacing Java.Interop's incompatible JavaProxyObject.java / JavaProxyThrowable.java only for _AndroidTypeMapImplementation=trimmable.
• [TrimmableTypeMap][NativeAOT] Initialize trimmable typemap runtime #11292 wired NativeAOT + trimmable typemap startup and populated NativeAOT JnienvInitializeArgs with GC-user-peer class refs, which is where the NativeAOT bridge path had to account for the trimmable GCUserPeerable shape.
• Add ManagedPeer native registration feature switch java-interop#1434 later added a feature switch so trimmable Android apps can disable legacy ManagedPeer native registration.

So the current difference appears to be historical layering rather than a fundamental GC bridge requirement: Mono/CoreCLR kept the older Android-compatible monodroid* Java peer API, while NativeAOT trimmable support was built around new generated net.dot.jni.* proxy sources that avoid the legacy Java.Interop native-registration shape. Follow-up issue: #11526 tracks unifying these Java peer reference APIs, likely by moving the trimmable path toward a single net.dot.* shape while NativeAOT is still experimental.

Size impact

Latest measurements on this branch use samples/NativeAOT/NativeAOT.csproj built in Release with _AndroidTypeMapImplementation=trimmable. APK sizes are for the signed APK.

Artifact	Parent libc++ baseline	No-libc++ build	Difference
arm64 APK	1,575,849 B	1,382,336 B	-193,513 B (-12.28%)
x64 APK	1,639,459 B	1,439,677 B	-199,782 B (-12.19%)
arm64 libNativeAOT.so	3,481,880 B	2,943,232 B	-538,648 B (-15.47%)
x64 libNativeAOT.so	3,404,896 B	2,866,728 B	-538,168 B (-15.81%)

libNativeAOT.so is the per-ABI native shared library packaged in the APK, for example lib/arm64-v8a/libNativeAOT.so. It is not the whole Android app package; the APK also contains manifest, resources, Java stubs/classes, signatures, and packaging assets.

Validation

Latest local validation:

• git diff --check
• make prepare CONFIGURATION=Debug
• make all CONFIGURATION=Debug progressed through native-mono, native-nativeaot, and native-clr; the remaining failure was a stale test restore asset issue unrelated to native code.
• ./dotnet-local.sh build src/native/native-nativeaot.csproj -c Debug --no-restore -v minimal
• ./dotnet-local.sh build src/native/native-clr.csproj -c Debug --no-restore -v minimal
• ./dotnet-local.sh build src/native/native-mono.csproj -c Debug --no-restore -v minimal
• ./dotnet-local.sh build samples/NativeAOT/NativeAOT.csproj -c Release -p:_AndroidTypeMapImplementation=trimmable -p:RuntimeIdentifier=android-arm64 -v minimal
• ./dotnet-local.sh build samples/NativeAOT/NativeAOT.csproj -c Release -p:_AndroidTypeMapImplementation=trimmable -p:RuntimeIdentifier=android-x64 -v minimal
• ./dotnet-local.sh build samples/NativeAOT/NativeAOT.csproj -c Debug -t:Install -p:RuntimeIdentifier=android-arm64
• launched samples/NativeAOT on an arm64 emulator and confirmed Application.OnCreate() and MainActivity.OnCreate() ran without fatal logcat entries.

Previous branch validation:

• dotnet test tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests.csproj --no-restore — 457 passed.
• rebuilt src/Xamarin.Android.Build.Tasks/Xamarin.Android.Build.Tasks.csproj;
• rebuilt NativeAOT runtime archives for android-arm64 and android-x64;
• built samples/NativeAOT/NativeAOT.csproj with _AndroidTypeMapImplementation=trimmable for android-arm64 and android-x64;
• verified generated NativeAOT link response files contain no libc++/libc++abi inputs;
• verified produced APKs contain no libc++ entries;
• verified llvm-nm -u reports no undefined C++ runtime-looking symbols in the final libNativeAOT.so outputs;
• smoke-tested the arm64 APK on an arm64 emulator: libNativeAOT.so loaded without libc++, MainApplication and MainActivity native callbacks ran, MainActivity.OnCreate() logged, and the process remained alive.

Notes

The x64 APK builds and packages without libc++, but local x64 runtime validation still needs an x64 emulator host because Android emulator x86_64 system images are not accepted on Apple Silicon/aarch64 hosts.

[simonrozsival]

Emulator validation update

I tested the signed NativeAOT + trimmable typemap sample APK on an arm64 emulator after rebuilding/overlaying the local validation packs.

What works:

• The arm64 APK installs and launches on emulator-5554.
• lib/arm64-v8a/libNativeAOT.so loads successfully with no libc++ packaged in the APK.
• Startup reaches managed code: MainApplication and MainActivity native callbacks run, MainActivity.OnCreate() logs, and the process remains alive.

Important caveats:

• This arm64 smoke currently requires trimmable NativeAOT startup fixes plus two validation-only workarounds:
  • pointing ILC TypeMapEntryAssembly at the app typemap (_NativeAOT.TypeMap) instead of the root _Microsoft.Android.TypeMaps, because scanning _Mono.Android.TypeMap currently fails on Android.Text.IInputType being present in the ref assembly but absent from the runtime assembly;
  • skipping UncaughtExceptionMarshaler setup for trimmable NativeAOT to avoid the IUncaughtExceptionHandler/JavaProxyThrowable startup path.
• I do not consider those two workarounds shippable as-is; they need separate root-cause fixes before this can be more than a feasibility proof.
• x64 builds and packages without libc++ (-nostdlib++ is in the link response and no libc++ entries are in the APK), but I could not run the x64 APK locally: the Android emulator rejects x86_64 system images on this Apple Silicon host (Avd's CPU Architecture 'x86_64' is not supported by the QEMU2 emulator on aarch64 host). x64 runtime behavior still needs validation on an x64 emulator host.

[simonrozsival]

@copilot resolve the merge conflicts in this pull request

[Copilot]

@copilot resolve the merge conflicts in this pull request

Resolved by merging origin/main into this branch and fixing all reported conflicts in commit 6e8b48a.

[simonrozsival]

@copilot resolve the merge conflicts in this pull request

[Copilot]

@copilot resolve the merge conflicts in this pull request

Resolved locally by merging origin/main and fixing the conflict hunks in commit 0199a84. Push from the agent is currently blocked by branch protection (GH013: Cannot update this protected ref), so this commit is ready but not yet on the remote branch.

[Copilot]

@copilot resolve the merge conflicts in this pull request

Done in 1c6205f. I merged latest origin/main into this branch and resolved all merge conflicts in the affected typemap generator/targets/tests files.

[Copilot]

Pull request overview

This PR (draft/WIP) explores removing the Android NativeAOT link-time dependency on libc++/libc++abi by adjusting MSBuild NativeAOT linking inputs and runtime component packaging, and by refactoring native runtime code paths to avoid pulling in C++ standard library symbols (including introducing minimal C++ allocation/nothrow shims).

Changes:

• Remove explicit libc++/libc++abi static link inputs and runtime component entries for NativeAOT Android builds.
• Add NativeAOT-local C++ runtime shims (operator new/delete + std::nothrow) and refactor multiple native components to avoid std::format/other STL usage.
• Refactor CLR/native logging and GC bridge processing (including callback plumbing for bridge processing and temporary peer map implementation changes).

Reviewed changes

Copilot reviewed 34 out of 34 changed files in this pull request and generated 3 comments.

Show a summary per file

File	Description
src/Xamarin.Android.Build.Tasks/Utilities/NativeRuntimeComponents.cs	Drops libc++/libc++abi from the known runtime archive list.
src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.NativeAOT.targets	Removes libc++/libc++abi from NativeAOT link inputs; updates linker/stdlib commentary.
src/native/nativeaot/include/host/host.hh	Adds NativeAOT host header shim include.
src/native/nativeaot/include/host/bridge-processing.hh	Adapts NativeAOT bridge-processing to callback-based shared implementation.
src/native/nativeaot/host/internal-pinvoke-stubs.cc	Simplifies abort path for unimplemented pinvokes to avoid extra std deps.
src/native/nativeaot/host/host.cc	Removes std::format usage from NativeAOT host logging path.
src/native/nativeaot/host/cxx-shims.cc	Adds minimal C++ allocation / nothrow shims to avoid libc++ dependency.
src/native/nativeaot/host/CMakeLists.txt	Adds cxx-shims.cc to NativeAOT host build.
src/native/nativeaot/host/bridge-processing.cc	Removes std::format usage and wires callbacks for NativeAOT bridge processing.
src/native/common/include/shared/helpers.hh	Adds Helpers::abort_applicationf formatted abort helper.
src/native/common/include/shared/cpp-util.hh	Removes C++ ranges/string allocations from diagnostics helpers and logging.
src/native/common/include/runtime-base/timing.hh	Replaces std::format timing log formatting with snprintf.
src/native/common/include/runtime-base/timing-internal.hh	Replaces std::format timing/internal warnings with snprintf-based logging.
src/native/common/include/runtime-base/strings.hh	Replaces some std-container usage and updates formatting/logging to avoid STL pulls.
src/native/common/include/runtime-base/jni-wrappers.hh	Replaces new[]/delete[] usage with malloc + placement-new where needed.
src/native/clr/shared/log_functions.cc	Introduces vprintf-style log helpers (log_writev, log_*_fmt).
src/native/clr/shared/helpers.cc	Adds implementation of Helpers::abort_applicationf; switches some fatal logging to printf-style.
src/native/clr/runtime-base/util.cc	Updates logging calls to new printf-style logging helpers.
src/native/clr/runtime-base/logger.cc	Refactors gref/lref log path storage away from std::string; updates open/log messages.
src/native/clr/runtime-base/android-system-shared.cc	Replaces some new[]/delete[] allocations and formatting with malloc/snprintf and fmt logging.
src/native/clr/include/shared/log_types.hh	Adds printf-style logging APIs and adjusts macro behavior for XA_HOST_NATIVEAOT builds.
src/native/clr/include/runtime-base/util.hh	Switches to formatted abort/log helpers; adds mmap failure formatted aborts and info logging.
src/native/clr/include/runtime-base/android-system.hh	Changes override-dir storage away from std::string for NativeAOT compatibility; API now returns const char*.
src/native/clr/include/host/os-bridge.hh	Adds formatted gref logging overloads and refactors internal logging helpers signatures.
src/native/clr/include/host/host-environment.hh	Updates debug/warn logging calls to avoid std::format and skip work when disabled.
src/native/clr/include/host/gc-bridge.hh	Replaces std::thread/semaphore with pthread/sem_t for compatibility and reduced STL usage.
src/native/clr/include/host/bridge-processing.hh	Removes now-unneeded CoreCLR no-op overrides after shared callback refactor.
src/native/clr/include/host/bridge-processing-shared.hh	Introduces callback plumbing and switches temporary peer map to robin_map.
src/native/clr/host/os-bridge.cc	Refactors stack-trace/gref logging to avoid std::format and centralize formatted logging.
src/native/clr/host/internal-pinvokes-shared.cc	Updates managed->native log forwarding to respect category enablement and use log_write.
src/native/clr/host/host-shared.cc	Replaces std::format/string_view literal usage in error logging with printf-style.
src/native/clr/host/gc-bridge.cc	Migrates to sem_wait/atomic builtins and updates logging formatting.
src/native/clr/host/fastdev-assemblies.cc	Updates override-dir handling to match AndroidSystem API change to const char*.
src/native/clr/host/bridge-processing.cc	Implements callback-based bridge processing shared logic and temporary peer lifecycle handling.

Comments suppressed due to low confidence (1)

src/native/clr/host/os-bridge.cc:203

• OSBridge::log_it() logs the main line to logcat unconditionally via log_write(...), even when logcat_enabled is false. This makes gref/lref logging emit to logcat even in the “file-only” configuration, and the logcat_enabled parameter only affects stack traces. Consider only calling log_write when logcat_enabled is true (and keep file writes independent), so behavior matches Logger::{gref,lref}_to_logcat().

void OSBridge::log_it (LogCategories category, const char *line, FILE *to, const char *const from, bool logcat_enabled) noexcept
{
	log_write (category, LogLevel::Info, line);

	// We skip logcat here when logging to file is enabled because _write_stack_trace will output to logcat as well, if enabled
	if (to == nullptr) {
		if (logcat_enabled) {
			_write_stack_trace (nullptr, from, category);
		}