Uh oh!
There was an error while loading. Please reload this page.
Decouple ILC from ManagedAssemblyToLink - #124801
Merged
Merged
Conversation
…puts Co-authored-by: sbomer <787361+sbomer@users.noreply.github.com>
CopilotAI
changed the title
[WIP] Fix ComputeIlcCompileInputs execution order before PrepareForILLinkDecouple NativeAOT ILLink assembly input computation from Feb 24, 2026
ComputeIlcCompileInputs
This was referenced Feb 24, 2026
…lyToLink Factor _PrepareTrimConfiguration out of PrepareForILLink so shared trim configuration operates on ResolvedFileToPublish and flows to both ILLink and ILC without duplication. For NativeAOT, _ComputeAssembliesToCompileToNative replaces CoreCLR runtime pack files with DefaultFrameworkAssemblies (tagged PostprocessAssembly=true) before _PrepareTrimConfiguration runs. _ComputeIlcCompileInputs then derives IlcReference from ResolvedFileToPublish via PostprocessAssembly metadata, ensuring ILC sees ILLink-relocated paths when both run. ComputeLinkedFilesToPublish hooks AfterTargets=ILLink (instead of ComputeResolvedFilesToPublishList) for correct ordering when both ILLink and ILC run. RunILLink is made conditional so projects can opt in. Remove ManagedAssemblies output from the C# task (replaced by ResolvedFileToPublish filtering). Add RuntimePackFilesToSkipPublish output for early removal of CoreCLR runtime pack files. Fix OOB assembly handling so overrides stay in ResolvedFileToPublish.
ComputeIlcCompileInputsSkip _ComputeIlcCompileInputs for framework library builds (BuildingFrameworkLibrary=true) since they use BuildOneFrameworkLibrary for input computation, not the publish-pipeline targets.
When NativeCompilationDuringPublish is false (e.g. Apple non-library-mode builds), Publish.targets is not imported so _ComputeIlcCompileInputs does not exist to populate IlcReference from ResolvedFileToPublish. Fall back to DefaultFrameworkAssemblies directly in ComputeIlcCompileInputs so ILC can find System.Private.CoreLib and other framework references.
sbomer
commented
Mar 2, 2026
Member
/azp list |
sbomer
commented
Mar 2, 2026
Member
/azp run runtime-nativeaot-outerloop |
sbomer
commented
Mar 2, 2026
Member
/azp run runtime-extra-platforms |
|
Azure Pipelines successfully started running 1 pipeline(s). |
1 similar comment
|
Azure Pipelines successfully started running 1 pipeline(s). |
This was referenced Mar 2, 2026
This was referenced Mar 12, 2026
sbomer
marked this pull request as ready for review
March 12, 2026 17:02
Contributor
There was a problem hiding this comment.
Pull request overview
Decouples NativeAOT’s ILLink preparation from ComputeIlcCompileInputs side effects by moving shared trim configuration into a dedicated target and rebuilding ILC/ILLink inputs from publish items rather than @(ManagedBinary).
Changes:
- Introduced
_PrepareTrimConfigurationin ILLink targets and made_ComputeManagedAssemblyToLinkdepend on it. - Updated NativeAOT publish pipeline to compute ILC inputs from
ResolvedFileToPublish(PostprocessAssembly=true) and adjusted ordering around ILLink. - Simplified/changed
ComputeManagedAssembliesToCompileToNativeoutputs to focus on runtime-pack files to remove and satellite assemblies.
Reviewed changes
Copilot reviewed 4 out of 4 changed files in this pull request and generated 3 comments.
| File | Description |
|---|---|
| src/tools/illink/src/ILLink.Tasks/build/Microsoft.NET.ILLink.targets | Adds _PrepareTrimConfiguration and moves shared trim defaults/metadata out of PrepareForILLink. |
| src/coreclr/tools/aot/ILCompiler.Build.Tasks/ComputeManagedAssembliesToCompileToNative.cs | Alters MSBuild task outputs and logic to support the updated publish/trim flow. |
| src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.targets | Removes NativeAOT’s PrepareForILLink dependency and shifts ILC trim metadata consumption. |
| src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Publish.targets | Reorders publish hooks around ILLink and selects ILC managed inputs via PostprocessAssembly. |
Uh oh!
There was an error while loading. Please reload this page.
Uh oh!
There was an error while loading. Please reload this page.
Uh oh!
There was an error while loading. Please reload this page.
…esToPublishList The AfterTargets="ILLink" hook is unnecessary because ComputeLinkedFilesToPublish's own DependsOnTargets chain (via LinkNative -> IlcCompile) transitively pulls in the correct prerequisites regardless of the AfterTargets anchor. Keeping ComputeResolvedFilesToPublishList avoids an artificial coupling to ILLink and removes the need for the ILLink insertion in the test infrastructure's LinkNativeIfBuildAndRun target.
# Conflicts: # src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.targets # src/tools/illink/src/ILLink.Tasks/build/Microsoft.NET.ILLink.targets
The _PrepareTrimConfiguration target was passing the full path of IntermediateAssembly to TrimmerRootAssembly, but ILLink expects assembly names (without path). This caused IL1032 errors across all CI platforms: 'Root assembly with name ...ilc.dll could not be found.' Restores the %(Filename) transform that was on main but got lost when moving this line from PrepareForILLink to _PrepareTrimConfiguration.
MichalStrehovsky
approved these changes
Mar 16, 2026
sbomer
enabled auto-merge (squash)
March 16, 2026 18:12
sbomer
commented
Mar 16, 2026
Member
/ba-g "deadletter" |
Uh oh!
There was an error while loading. Please reload this page.
jonathanpeppers added a commit
to dotnet/android
that referenced
this pull request
Mar 19, 2026
Context: dotnet/runtime#124801 The runtime restructured NativeAOT build targets so that _ComputeAssembliesToCompileToNative now populates @(_IlcManagedInputAssemblies) and ComputeLinkedFilesToPublish removes them from @(ResolvedFileToPublish). Since .NET for Android runs ILLink before ILC (to support custom trimmer steps), our assemblies are already trimmed and must remain in @(ResolvedFileToPublish) for the outer build's _ResolveAssemblies target. Clear @(_IlcManagedInputAssemblies) in our _AndroidComputeIlcCompileInputs target so the runtime's ComputeLinkedFilesToPublish doesn't strip them. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
jonathanpeppers added a commit
to dotnet/android
that referenced
this pull request
Mar 19, 2026
Changes: dotnet/dotnet@5ff448a...803eb28 - **Dependency Updates**: - From [11.0.0-preview.3.26165.107 to 11.0.0-preview.3.26168.106][1] - Microsoft.NET.Workload.Mono.ToolChain.Current.Manifest-11.0.100-preview.3 - Microsoft.NET.ILLink - Microsoft.NETCore.App.Ref - From [11.0.0-beta.26165.107 to 11.0.0-beta.26168.106][1] - Microsoft.DotNet.Build.Tasks.Feed - From [0.11.5-preview.26165.107 to 0.11.5-preview.26168.106][1] - Microsoft.DotNet.Cecil - From [11.0.100-preview.3.26165.107 to 11.0.100-preview.3.26168.106][1] - Microsoft.NET.Sdk - Microsoft.NET.Workload.Emscripten.Current.Manifest-11.0.100-preview.3 - Microsoft.TemplateEngine.Authoring.Tasks [1]: dotnet/dotnet@5ff448a...803eb28 ## Other changes ## [xabt] Prevent `ComputeLinkedFilesToPublish` from stripping assemblies Context: dotnet/runtime#124801 The runtime restructured NativeAOT build targets so that `_ComputeAssembliesToCompileToNative` now populates `@(_IlcManagedInputAssemblies)` and `ComputeLinkedFilesToPublish` removes them from `@(ResolvedFileToPublish)`. Since .NET for Android runs ILLink before ILC (to support custom trimmer steps), our assemblies are already trimmed and must remain in `@(ResolvedFileToPublish)` for the outer build's `_ResolveAssemblies` target. Clear `@(_IlcManagedInputAssemblies)` in our `_AndroidComputeIlcCompileInputs` target so the runtime's `ComputeLinkedFilesToPublish` doesn't strip them. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Co-authored-by: Jonathan Peppers <jonathan.peppers@microsoft.com>
sbomer added a commit
that referenced
this pull request
Mar 24, 2026
…g them (#124192) ## Description NativeAOT embeds satellite assemblies into the native binary but still copies them to the publish folder. After PR #124801 refactored the NativeAOT build integration to work with `ResolvedFileToPublish` directly, this fix removes project satellite assemblies from that item group. **Fix:** Add removal of `IntermediateSatelliteAssembliesWithTargetPath` from `ResolvedFileToPublish` in the `ComputeLinkedFilesToPublish` target: ```xml <ItemGroup> <ResolvedFileToPublish Remove="@(_IlcManagedInputAssemblies)" /> <!-- dotnet CLI produces managed debug symbols, which we will replace with native symbols instead --> <ResolvedFileToPublish Remove="@(_DebugSymbolsIntermediatePath)" /> <!-- Satellite assemblies are embedded into the native binary, so we don't need to publish them --> <ResolvedFileToPublish Remove="@(IntermediateSatelliteAssembliesWithTargetPath)" /> <!-- replace apphost with binary we generated during native compilation --> <ResolvedFileToPublish Include="$(NativeBinary)"> <RelativePath>$(NativeBinaryPrefix)$(TargetName)$(NativeBinaryExt)</RelativePath> <CopyToPublishDirectory>PreserveNewest</CopyToPublishDirectory> </ResolvedFileToPublish> </ItemGroup> ``` This follows the same pattern as removing managed assemblies and debug symbols, which are also embedded or replaced in the native binary. ## Customer Impact - **Affected customers:** NativeAOT users with localized resources - **Regression:** No - **Source incompatibility:** No - **Breaking change:** No (removes extraneous files from publish output) ## Testing Testing will be added in the SDK repo per review feedback. The fix can be validated by publishing a NativeAOT app with satellite assemblies and verifying that: - Localized resources are accessible at runtime (embedded correctly) - No satellite assembly subdirectories exist in publish output ## Risk Minimal. One-line change following established pattern. Satellite assemblies remain embedded and functional; only removes redundant disk copies. <!-- START COPILOT ORIGINAL PROMPT --> <details> <summary>Original prompt</summary> ---- *This section details on the original issue you should resolve* <issue_title>AOT publish includes satellite assemblies in publish folder</issue_title> <issue_description>### Describe the bug Publishing an AOT app will include satellite resource assemblies (for example `<language>\AppName.resources.dll` in the output folder. It appears that these are also embedded in the NativeAOT executable, the app can still show localized strings even if these are deleted. Ideally if these satellite assemblies are not needed, they should not be copied to the publish folder. As it is, it's confusing and makes it look like they need to be deployed with the app. ### To Reproduce - Create a console app - Set `PublishAot` to true in the .csproj file - Add a resx file and a localized resx file with a string resource in them (for example Strings.resx and Strings.es.resx) - Publish the app **Expected:** No language subfolders and satellite assemblies in the publish folder **Actual:** Language subfolders with satellite assemblies are present in the publish folder [Repro project](https://github.com/user-attachments/files/25188858/AotLocalization.zip) [Binlog](https://github.com/user-attachments/files/25188847/AotLocalizationBinlog.zip) ### Further technical details .NET SDK version: 10.0.102</issue_description> <agent_instructions>Fix this bug. Pay attention to the analysis from @baronfel about how to fix it.</agent_instructions> ## Comments on the Issue (you are @copilot in this section) <comments> <comment_new><author>@baronfel</author><body> I gave this problem to Copilot CLI equipped with the viktorhofer/dotnet-skills plugin, and here was its analysis after publishing + inspecting the binlog: ## Root Cause Analysis The satellite assemblies (e.g. `es\AppName.resources.dll`) end up in the NativeAOT publish output because the NativeAOT build integration correctly **embeds** them into the native binary but fails to **remove** them from the publish file list, so the SDK's generic publish pipeline copies them to the output directory anyway. ### How satellite assemblies flow through the pipeline **Step 1: NativeAOT collects satellite assemblies for embedding** In [`Microsoft.NETCore.Native.Publish.targets` (dotnet/runtime)](https://github.com/dotnet/runtime/blob/main/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Publish.targets#L3-L11), `_ComputeIlcCompileInputs` gathers satellite assemblies from two sources: ```xml <IlcSatelliteAssembly Include="@(_SatelliteAssembliesToPublish)" /> <IlcSatelliteAssembly Include="@(IntermediateSatelliteAssembliesWithTargetPath)" /> ``` - `_SatelliteAssembliesToPublish` = satellite assemblies from package/project references (extracted from `_ResolvedCopyLocalPublishAssets` by [`ComputeManagedAssembliesToCompileToNative`](https://github.com/dotnet/runtime/blob/main/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Publish.targets#L73-L84)) - `IntermediateSatelliteAssembliesWithTargetPath` = the **project's own** satellite assemblies (e.g. `es\52913-resx-in-nativeaot.resources.dll`) These are passed to ILC via [`--satellite:` in `Microsoft.NETCore.Native.targets`](https://github.com/dotnet/runtime/blob/main/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.targets#L236), which embeds them into the native binary. This part works correctly — the app can resolve localized strings even if the satellite DLLs are deleted from disk. **Step 2: `ComputeLinkedFilesToPublish` cleans up the publish list — but misses the project's own satellites** [`ComputeLinkedFilesToPublish`](https://github.com/dotnet/runtime/blob/main/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Publish.targets#L20-L34) runs `BeforeTargets="ComputeResolvedFilesToPublishList"` and modifies the publish list: ```xml <_ResolvedCopyLocalPublishAssets Remove="@(_AssembliesToSkipPublish)" /> <!-- removes package satellites --> <_ResolvedCopyLocalPublishAssets Include="@(_LinkedResolvedAssemblies)" /> <_DebugSymbolsIntermediatePath Remove="@(_DebugSymbolsIntermediatePath)" /> <IntermediateAssembly Remove="@(IntermediateAssembly)" /> <!-- replaces managed .dll with native binary --> <IntermediateAssembly Include="$(NativeBinary)" /> ``` This successfully removes package-reference satellite assemblies (via `_AssembliesToSkipPublish`) and replaces the managed assembly with the native binary. **But it does NOT remove `IntermediateSatelliteAssembliesWithTargetPath`.** **Step 3: The SDK unconditionally re-adds the project's satellite assemblies to publish** In [`Microsoft.NET.Publish.targets` (dotnet/sdk)](https://github.com/dotnet/sdk/blob/main/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Publish.targets#L545-L549), `ComputeResolvedFilesToPublishList` unconditionally includes: ```xml <!-- Copy satellite assemblies. --> <ResolvedFileToPublish Include="@(IntermediateSatelliteAssembliesWithTargetPath)"> <RelativePath>%(IntermediateSatelliteAss... </details> <!-- START COPILOT CODING AGENT SUFFIX --> - Fixes#124191 <!-- START COPILOT CODING AGENT TIPS --> --- 💡 You can make Copilot smarter by setting up custom instructions, customizing its development environment and configuring Model Context Protocol (MCP) servers. Learn more [Copilot coding agent tips](https://gh.io/copilot-coding-agent-tips) in the docs. --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: dsplaisted <145043+dsplaisted@users.noreply.github.com> Co-authored-by: MichalStrehovsky <13110571+MichalStrehovsky@users.noreply.github.com> Co-authored-by: Sven Boemer <sbomer@gmail.com>
sbomer added a commit
that referenced
this pull request
Apr 10, 2026
… item Update (#125630) ## Description Follow-up to PR #124801 review feedback: the "intersection via include/remove, then remove+re-include" pattern in `_PrepareTrimConfiguration` was complex, mutated item ordering, and used two throwaway item groups. Replace with a direct MSBuild `Update`. ### Change **Before** — compute intersection manually to set metadata, then remove+re-add items: ```xml <__SingleWarnIntermediateAssembly Include="@(ResolvedFileToPublish)" /> <__SingleWarnIntermediateAssembly Remove="@(IntermediateAssembly)" /> <_SingleWarnIntermediateAssembly Include="@(ResolvedFileToPublish)" /> <_SingleWarnIntermediateAssembly Remove="@(__SingleWarnIntermediateAssembly)" /> <_SingleWarnIntermediateAssembly> <TrimmerSingleWarn Condition="...">false</TrimmerSingleWarn> </_SingleWarnIntermediateAssembly> <ResolvedFileToPublish Remove="@(_SingleWarnIntermediateAssembly)" /> <ResolvedFileToPublish Include="@(_SingleWarnIntermediateAssembly)" /> ``` **After** — update matching items directly, preserving order: ```xml <ResolvedFileToPublish Update="@(IntermediateAssembly)"> <TrimmerSingleWarn Condition=" '%(ResolvedFileToPublish.TrimmerSingleWarn)' == '' ">false</TrimmerSingleWarn> </ResolvedFileToPublish> ``` ## Changes proposed in this pull request - [`Microsoft.NET.ILLink.targets`] Replace 13-line intersection pattern with a 3-line `Update` in `_PrepareTrimConfiguration` - [`Microsoft.NET.ILLink.targets`] Qualify `%(TrimmerSingleWarn)` as `%(ResolvedFileToPublish.TrimmerSingleWarn)` in the `Update` condition to prevent MSB4096 (unqualified metadata batching over all `ResolvedFileToPublish` items, including those without the metadata defined) ## Additional context <!-- START COPILOT CODING AGENT TIPS --> --- 🔒 GitHub Advanced Security automatically protects Copilot coding agent pull requests. You can protect all pull requests by enabling Advanced Security for your repositories. [Learn more about Advanced Security.](https://gh.io/cca-advanced-security) --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: sbomer <787361+sbomer@users.noreply.github.com>
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.
_ComputeManagedAssemblyForILLinkin NativeAOT was indirectly dependent onComputeIlcCompileInputsvia@(ManagedBinary), which madePrepareForILLinkordering-sensitive and broke incremental ILLink behavior when ILLink is run before ILC input computation. This change removes that coupling so ILLink preparation no longer relies onComputeIlcCompileInputsside effects.What changed
src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.targetsin_ComputeManagedAssemblyForILLink.@(ManagedBinary)with@(IntermediateAssembly)when reconstructing@(ManagedAssemblyToLink).Why this matters
@(IntermediateAssembly)is available duringPrepareForILLink, independent ofComputeIlcCompileInputs.@(ManagedAssemblyToLink)regardless of whetherComputeIlcCompileInputsruns before or afterPrepareForILLink/ILLink.Code change
Original prompt
💡 You can make Copilot smarter by setting up custom instructions, customizing its development environment and configuring Model Context Protocol (MCP) servers. Learn more Copilot coding agent tips in the docs.