Uh oh!
There was an error while loading. Please reload this page.
[NativeAOT] Take over native linker invocation from ILC targets - #11148
Merged
Conversation
Set NativeLib=static so ILC produces a .a archive via ar instead of invoking the linker directly. Add _AndroidLinkNativeAotSharedLibrary target that runs after LinkNative and links the ILC .o output into a .so using the NDK clang wrapper. This gives Android full control over the native linker invocation, following the same approach used by macios. Reproduce the flags that LinkNative and SetupOSSpecificProps would have provided for NativeLib=Shared: - -shared, -Wl,-e,0x0, -Wl,-z,max-page-size=16384 (from LinkerArg) - --version-script, --export-dynamic, --discard-all, --gc-sections (from CustomLinkerArg inside LinkNative) - -fuse-ld=lld (from LinkerArg via LinkerFlavor) - sections.ld linker script to retain the __modules section Set IlcExportUnmanagedEntrypoints=true so ILC exports [UnmanagedCallersOnly] methods as native symbols, required for JNI entry points. Clear LinkerFlavor inside _AndroidBeforeIlcCompile to work around an ILC targets bug where _LinkerVersion detection is skipped for NativeLib=Static but the numeric comparison in LinkNative still evaluates. Context: dotnet/runtime#126978 The resulting linker command line is identical to the original. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Contributor
There was a problem hiding this comment.
Pull request overview
This PR adjusts the NativeAOT MSBuild flow for .NET for Android so Android (NDK clang wrapper) performs the final shared-library link step instead of ILC, aligning linker invocation control with other platforms (e.g., macios).
Changes:
- Set
NativeLib=staticso ILC produces a static archive rather than directly linking a.so. - Add
_AndroidLinkNativeAotSharedLibraryto link ILC output into a.sousing the NDK clang wrapper and restore required linker flags/scripts. - Ensure unmanaged entrypoints are exported and tweak linker-related properties/soname/publish naming to match Android expectations.
Uh oh!
There was an error while loading. Please reload this page.
Add Inputs/Outputs to _AndroidLinkNativeAotSharedLibrary so incremental builds can skip relinking when inputs haven't changed. Add FileWrites for the .so and sections.ld so Clean can account for generated files. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Comment on lines
+278
to
+281
| <Target Name="_AndroidLinkNativeAotSharedLibrary" | ||
| AfterTargets="LinkNative" | ||
| Inputs="$(NativeObject);@(NativeLibrary)" | ||
| Outputs="$(NativeOutputPath)$(NativeBinaryPrefix)$(TargetName).so"> |
There was a problem hiding this comment.
Do managed assemblies also need to be Inputs? Someone could add their own [UnmanagedCallersOnly] and it wouldn't get picked up in an incremental build.
Honestly, this is NativeAOT (Release-mode only), maybe we could just let this always run if LinkNative ran?
MemberAuthor
There was a problem hiding this comment.
I think if someone adds [UCO] it would cause ILC to re-run, produce a new $(NativeObject) and that would make this target run.
These are the same inputs/outputs as the LinkNative target so it should already be running if LinkNative ran. If we remove the Inputs/Outputs, it would always run even if LinkNative was skipped.
jonathanpeppers
commented
Apr 17, 2026
Member
/review |
Contributor
✅ Android PR Reviewer completed successfully! |
Contributor
There was a problem hiding this comment.
🤖 AI Review Summary
Verdict: ✅ LGTM
Found 0 errors, 0 warnings, 2 suggestions.
Analysis
The PR correctly transitions NativeAOT from delegating shared library linking to ILC's LinkNative target to having Android handle it directly via _AndroidLinkNativeAotSharedLibrary. I verified the approach against the ILC targets in dotnet/runtime:
@(NativeLibrary)items are correctly consumed — ILC'sMicrosoft.NETCore.Native.Unix.targetsmerges them into@(LinkerArg)(line 243 in the runtime), so@(LinkerArg)is the single source for all linker inputs. ✅NativeLib=static+IlcExportUnmanagedEntrypoints=truecorrectly makes ILC produce a.aviaarwhile still exporting JNI entry points. ✅LinkerFlavorclearing is a sound workaround for dotnet/runtime#126978 — with NativeLib=static, ILC skips_LinkerVersiondetection but still evaluates a numeric comparison. ✅- Hardcoded
.soreplacing$(NativeBinaryExt)is correct — with NativeLib=static,$(NativeBinaryExt)would be.a, which is wrong for soname and file matching. ✅ - Incremental build support —
Inputs/OutputsandFileWritesare properly set. TheFileWritesitems in the<ItemGroup>inside the target will evaluate even when the target is skipped. ✅ - Linker flags reproduce what ILC's
LinkNative+SetupOSSpecificPropswould provide forNativeLib=Shared(verified against the runtime source). ✅
CI Status
- 🟢 Linux: passed
- 🔴 Windows: failed (unable to access Azure DevOps logs to confirm if related to this PR or pre-existing)
- 🟡 macOS: in progress
- ⏳ Overall: queued
Suggestions
- 💡 Add a comment explaining that
@(NativeLibrary)is consumed indirectly via@(LinkerArg)(Microsoft.Android.Sdk.NativeAOT.targets:299) - 💡 Document why
sections.ldand--gc-sectionsare unconditional (NDK always uses LLD) (Microsoft.Android.Sdk.NativeAOT.targets:298)
👍 Well-structured change with excellent inline documentation. The approach of taking over the linker invocation (matching what macios does) gives Android full control over the native link step, which is the right architectural direction.
Review generated by android-reviewer from review guidelines.
Warning
⚠️ Firewall blocked 1 domain
The following domain was blocked by the firewall during workflow execution:
dev.azure.com
To allow these domains, add them to the network.allowed list in your workflow frontmatter:
network:
allowed:
- defaults
- "dev.azure.com"See Network Configuration for more information.
Generated by Android PR Reviewer for issue #11148 · ● 9.6M
Uh oh!
There was an error while loading. Please reload this page.
Uh oh!
There was an error while loading. Please reload this page.
On Windows, ILC's LinkNative writes linker args to a response file instead of passing them inline — cmd.exe has quoting issues with spaces in paths. Match that behavior in _AndroidLinkNativeAotSharedLibrary. Fixes NativeAOT build failures for projects with spaces or special characters in their names (e.g. CheckProjectWithSpaceInNameWorks tests). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
ILC's LinkNative target defaults CppLibCreator to the host 'ar', which does not understand ELF objects when cross-compiling for Android. On macOS this caused Xcode's ranlib to emit spurious 'empty table of contents' warnings for every ABI. Set CppLibCreator to llvm-ar (from the NDK toolchain, already on PATH) so the archiver can correctly process ELF .o files. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This reverts commit 2ff10fb.
ILC's LinkNative target strips symbols via llvm-objcopy after linking, but those steps are skipped when NativeLib=Static. Add the same three objcopy invocations to _AndroidLinkNativeAotSharedLibrary: 1. Extract debug info to .dbg file 2. Strip debug symbols from the .so 3. Add gnu-debuglink back to the .so Without stripping, the .so was ~8MB larger than the original, causing BuildReleaseArm64 apkdiff regression tests to fail. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
jonathanpeppers
approved these changes
Apr 30, 2026
Uh oh!
There was an error while loading. Please reload this page.
sbomer added a commit
that referenced
this pull request
May 13, 2026
Adds an opt-in `_AndroidUseWorkloadNativeLinker` property that allows NativeAOT builds to use the linker and sysroot files from the workload runtime pack instead of requiring the Android NDK. This is the foundation for removing the NDK dependency from NativeAOT builds (issue #10697). ### What changed **Workload linker opt-in** (`Microsoft.Android.Sdk.NativeAOT.targets`) - When `_AndroidUseWorkloadNativeLinker=true`, the NativeAOT link step resolves CRT objects, system lib stubs, and toolchain libraries from the runtime pack instead of the NDK. - When false (default), behavior is unchanged — NDK paths are used as before. **NativeAOT-specific redist directory** (`Step_Android_SDK_NDK.cs`) - Copies a second set of CRT objects and system lib stubs from NDK API level 24 into `redist-nativeaot/` during `make prepare`. - NativeAOT needs API 24+ stubs because dotnet/runtime's `libSystem.Native.a` references symbols introduced at that level (`__gnu_strerror_r`, `__write_chk`, `preadv`, `pwritev`, `stderr`). - Mono/CoreCLR continue using the API 21 stubs from `redist/`. **Runtime pack contents** (`Microsoft.Android.Runtime.proj`) - NativeAOT pack now includes CRT objects (`crtbegin_so.o`, `crtend_so.o`) and system lib stubs from `redist-nativeaot/` (API 24). - Added toolchain libraries (`libc++_static.a`, `libc++abi.a`, `libclang_rt.builtins`, `libunwind.a`) that were previously only in the CoreCLR pack. **Tests** (`NativeAotBuildTests.cs`) - `BuildNativeAot_WithoutNdk_Fails`: Verifies that NativeAOT builds fail without NDK when the workload linker is not enabled. - `BuildNativeAot_WithWorkloadLinker_WithoutNdk`: Verifies that NativeAOT builds succeed with the workload linker and no NDK installed. ### Context This is the third step in the NDK-free NativeAOT linking series: 1. ✅ #11148 — Take over native linker invocation from ILC (NativeLib=static) 2. ✅ #11256 — Replace clang with direct lld invocation via LinkNativeAotSharedLibrary task 3. **This PR** — Source all linker dependencies from the workload pack The `_AndroidUseWorkloadNativeLinker` property is underscore-prefixed (internal) for now. A future PR will make it the default. Contributes to #10697.
6 tasks
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for freeto subscribe to this conversation on GitHub.
Already have an account?
Sign in.
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Set NativeLib=static so ILC produces a .a archive via ar instead of invoking the linker directly. Add _AndroidLinkNativeAotSharedLibrary target that runs after LinkNative and links the ILC .o output into a .so using the NDK clang wrapper. This gives Android full control over the native linker invocation, following the same approach used by macios.
Reproduce the flags that LinkNative and SetupOSSpecificProps would have provided for NativeLib=Shared:
Set IlcExportUnmanagedEntrypoints=true so ILC exports [UnmanagedCallersOnly] methods as native symbols, required for JNI entry points.
Clear LinkerFlavor inside _AndroidBeforeIlcCompile to work around an ILC targets bug where _LinkerVersion detection is skipped for NativeLib=Static but the numeric comparison in LinkNative still evaluates. Context: dotnet/runtime#126978
The resulting linker command line is identical to the original.
Contributes to #10697