path: root/src/ILLink.Tasks/ILLink.Tasks.targets

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

  <PropertyGroup>
    <_LinkTaskDirectoryRoot>$(MSBuildThisFileDirectory)../tools/</_LinkTaskDirectoryRoot>
    <_LinkTaskTFM Condition=" '$(MSBuildRuntimeType)' == 'Core' ">netcoreapp3.0</_LinkTaskTFM>
    <_LinkTaskTFM Condition=" '$(_LinkTaskTFM)' == '' ">net46</_LinkTaskTFM>
    <_LinkTaskDirectory>$(_LinkTaskDirectoryRoot)$(_LinkTaskTFM)/</_LinkTaskDirectory>
    <LinkTaskDllPath Condition=" '$(LinkTaskDllPath)' == '' ">$(_LinkTaskDirectory)ILLink.Tasks.dll</LinkTaskDllPath>
  </PropertyGroup>

  <PropertyGroup>
    <!-- LinkDuringPublish allows the linker to be disabled by passing
         a property on the command-line. (/p:LinkDuringPublish=false)
         -->
    <LinkDuringPublish Condition=" '$(LinkDuringPublish)' == '' ">true</LinkDuringPublish>
    <LinkDuringPublish Condition=" '$(LinkDuringPublish)' != 'true' ">false</LinkDuringPublish>
    <ShowLinkerSizeComparison Condition=" '$(ShowLinkerSizeComparison)' == '' ">false</ShowLinkerSizeComparison>
    <LinkerDumpDependencies Condition=" '$(LinkerDumpDependencies)' == '' ">false</LinkerDumpDependencies>
    <UsedApplicationAssemblyAction Condition=" '$(UsedApplicationAssemblyAction)' == '' ">Copy</UsedApplicationAssemblyAction>
    <UnusedApplicationAssemblyAction Condition=" '$(UnusedApplicationAssemblyAction)' == '' ">Delete</UnusedApplicationAssemblyAction>
    <UsedPlatformAssemblyAction Condition=" '$(UsedPlatformAssemblyAction)' == '' and '$(SelfContained)' == 'true' ">AddBypassNGen</UsedPlatformAssemblyAction>
    <UsedPlatformAssemblyAction Condition=" '$(UsedPlatformAssemblyAction)' == '' ">Skip</UsedPlatformAssemblyAction>
    <UnusedPlatformAssemblyAction Condition=" '$(UnusedPlatformAssemblyAction)' == '' and '$(SelfContained)' == 'true' ">Delete</UnusedPlatformAssemblyAction>
    <UnusedPlatformAssemblyAction Condition=" '$(UnusedPlatformAssemblyAction)' == '' ">Skip</UnusedPlatformAssemblyAction>
    <RootAllApplicationAssemblies Condition=" '$(RootAllApplicationAssemblies)' == '' ">true</RootAllApplicationAssemblies>
    <RootAllApplicationAssemblies Condition=" '$(RootAllApplicationAssemblies)' != 'true' ">false</RootAllApplicationAssemblies>
    <LinkerTrimNativeDeps Condition=" '$(LinkerTrimNativeDeps)' == '' ">true</LinkerTrimNativeDeps>
    <LinkerTrimNativeDeps Condition=" '$(LinkerTrimNativeDeps)' != 'true' ">false</LinkerTrimNativeDeps>
    <ClearInitLocals Condition=" '$(ClearInitLocals)' == '' ">false</ClearInitLocals>
  </PropertyGroup>

  <ItemGroup>
    <!-- LinkerRootDescriptors (the ItemGroup) is set to contain
         LinkerRootDescriptors (the Property), which allows adding
         linker roots on the command-line
         (/p:LinkerRootDescriptors=path/to/a.xml;path/to/b.xml;). These
         are relative paths from the project to the xml file.
         LinkerRootDescriptors (the ItemGroup) can also be set in the
         project file, and these will be included in addition to those
         specified on the command-line. -->
    <LinkerRootDescriptors Include="$(LinkerRootDescriptors)" />
  </ItemGroup>

  <!-- By default, the linker will generate roots for the intermediate
       assembly that root everything in the assembly. -->
  <PropertyGroup>
    <_IntermediateRootDescriptorName Condition=" '$(_IntermediateRootDescriptorName)' == '' ">IntermediateAssemblyRoots.xml</_IntermediateRootDescriptorName>
    <_IntermediateRootDescriptorPath Condition=" '$(_IntermediateRootDescriptorPath)' == '' ">$(IntermediateOutputPath)$(_IntermediateRootDescriptorName)</_IntermediateRootDescriptorPath>
  </PropertyGroup>

  <!-- The linker will place linked assemblies into an intermediate
       directory, and hook into the rest of the publish pipeline to
       publish the linked assemblies instead of those given as input
       to the linker. -->
  <PropertyGroup>
    <IntermediateLinkDirName Condition=" '$(IntermediateLinkDirName)' == '' ">linked</IntermediateLinkDirName>
    <IntermediateLinkDir Condition=" '$(IntermediateLinkDir)' == '' ">$(IntermediateOutputPath)$(IntermediateLinkDirName)</IntermediateLinkDir>
  </PropertyGroup>

  <!-- Used to enable incremental build for the link target. -->
  <PropertyGroup>
    <_LinkSemaphore>$(IntermediateOutputPath)Link.semaphore</_LinkSemaphore>
  </PropertyGroup>

  <!--
      This target runs the linker during the publish pipeline. The
      publish pipeline has a target called ComputeFilesToPublish,
      which computes the ItemGroup ResolvedFileToPublish. To extend
      this target, we insert a target before
      ComputeFilesToPublish. Our target rewrites the relevant inputs
      (@(IntermediateAssembly), @(ResolvedAssembliesToPublish)). This
      lets ComputeFilesToPublish be ignorant of the linker, but
      changes the meaning of IntermediateAssembly and
      ResolvedAssembliesToPublish.

      To include linked pdbs in the publish output, we also rewrite
      the ComputeFilesToPublish input
      @(_DebugSymbolsIntermediatePath). Note that this is a private
      itemgroup, so relying on this is not ideal.
  -->
  <!-- DependsOnTargets here doesn't include the targets that compute
       ResolvedAssembliesToPublish or IntermediateAssembly, because
       ComputeFilesToPublish already depends on
       these. BeforeTargets="ComputeFilesToPublish" ensures that
       ComputeLinkedFilesToPublish will run before
       ComputeFilesToPublish, but after all of its dependencies. -->
  <Target Name="ComputeLinkedFilesToPublish"
          BeforeTargets="ComputeFilesToPublish"
          DependsOnTargets="_ComputeLinkedAssemblies;_FindNativeDeps;_RemoveDuplicatesFrom_ResolvedCopyLocalPublishAssets"
          Condition=" '$(LinkDuringPublish)' == 'true' ">
    <!-- Rewrite ResolvedAssembliesToPublish, which is an input to
         ComputeFilesToPublish. -->
    <ItemGroup>
      <_ResolvedCopyLocalPublishAssets Remove="@(_ManagedAssembliesToLink)" />
      <_ResolvedCopyLocalPublishAssets Remove="@(_NativeResolvedDepsToPublish)" />
      <_ResolvedCopyLocalPublishAssets Include="@(_NativeKeptDepsToPublish)" />
      <_ResolvedCopyLocalPublishAssets Include="@(_LinkedResolvedAssemblies)" />
    </ItemGroup>

    <!-- Rewrite IntermediateAssembly, which is an input to
         ComputeFilesToPublish. -->
    <ItemGroup>
      <IntermediateAssembly Remove="@(IntermediateAssembly)" />
      <IntermediateAssembly Include="@(_LinkedIntermediateAssembly)" />
    </ItemGroup>

    <!-- Rewrite _DebugSymbolsIntermediatePath, which is an input to
         ComputeFilesToPublish. -->
    <ItemGroup>
      <_DebugSymbolsIntermediatePath Remove="@(_DebugSymbolsIntermediatePath)" Condition=" '$(_DebugSymbolsProduced)' == 'true' " />
      <_DebugSymbolsIntermediatePath Include="@(_LinkedDebugSymbols)" Condition=" '$(_DebugSymbolsProduced)' == 'true' " />
    </ItemGroup>
  </Target>

  <!-- Work around duplicate items in
       _ResolvedCopyLocalPublishAssets. See
       https://github.com/dotnet/sdk/issues/3007. -->
  <Target Name="_RemoveDuplicatesFrom_ResolvedCopyLocalPublishAssets">
    <RemoveDuplicates Inputs="@(_ResolvedCopyLocalPublishAssets)">
      <Output TaskParameter="Filtered" ItemName="_Unique_ResolvedCopyLocalPublishAssets" />
    </RemoveDuplicates>
    <ItemGroup>
      <_ResolvedCopyLocalPublishAssets Remove="@(_ResolvedCopyLocalPublishAssets)" />
      <_ResolvedCopyLocalPublishAssets Include="@(_Unique_ResolvedCopyLocalPublishAssets)" />
    </ItemGroup>
  </Target>

  <!-- The SDK has a target called ComputeRefAssembliesToPublish that
       runs after ComputeFilesToPublish and rewrites
       ResolvedFileToPublish to include any reference assemblies that
       aren't in ResolvedAssembliesToPublish. Because
       ComputeLinkedFilesToPublish changes ResolvedAssembliesToPublish
       (replacing the original assemblies with linked assemblies),
       this would change the behavior of
       ComputeRefAssembliesToPublish, resulting in extra assemblies
       being placed in the refs directory of the output. To prevent
       this, we save ResolvedAssembliesToPublish before linking, and
       restore it to its pre-link state before
       ComputeRefAssembliesToPublish. -->
  <Target Name="SaveResolvedAssembliesToPublish"
          BeforeTargets="ComputeLinkedFilesToPublish"
          DependsOnTargets="_RemoveDuplicatesFrom_ResolvedCopyLocalPublishAssets">
    <ItemGroup>
      <PreLinkResolvedAssembliesToPublish Include="@(_ResolvedCopyLocalPublishAssets)" />
    </ItemGroup>
  </Target>
  <Target Name="RestoreResolvedAssembliesToPublish"
          BeforeTargets="ComputeRefAssembliesToPublish">
    <ItemGroup>
      <_ResolvedCopyLocalPublishAssets Remove="@(_ResolvedCopyLocalPublishAssets)" />
      <_ResolvedCopyLocalPublishAssets Include="@(PreLinkResolvedAssembliesToPublish)" />
    </ItemGroup>
  </Target>

  <!-- Print out a size comparison report for the linked
       assemblies. This is disabled by default, but can be turned on
       by setting $(ShowLinkerSizeComparison) to true. This runs after
       the ComputeFilesToPublish, so it is output even during
       incremental builds and takes into account all transformations
       on the files to be published. -->
  <UsingTask TaskName="CompareAssemblySizes" AssemblyFile="$(LinkTaskDllPath)" />
  <UsingTask TaskName="FilterByMetadata" AssemblyFile="$(LinkTaskDllPath)" />
  <Target Name="_CompareLinkedAssemblySizes"
          AfterTargets="ComputeFilesToPublish"
          DependsOnTargets="_ComputeManagedAssembliesToLink;_ComputeLinkedAssemblies;_RemoveDuplicatesFrom_ResolvedCopyLocalPublishAssets"
          Condition=" '$(LinkDuringPublish)' == 'true' And '$(ShowLinkerSizeComparison)' == 'true' ">
    <FilterByMetadata Items="@(_ResolvedCopyLocalPublishAssets);@(IntermediateAssembly)"
                      MetadataName="Filename"
                      MetadataValues="@(_ManagedAssembliesToLink->'%(Filename)')">
      <Output TaskParameter="FilteredItems" ItemName="_FinalAssembliesTouchedByLinker" />
    </FilterByMetadata>
    <CompareAssemblySizes UnlinkedAssemblies="@(_ManagedAssembliesToLink)"
                          LinkedAssemblies="@(_FinalAssembliesTouchedByLinker)" />
  </Target>


  <!-- Computes _LinkedResolvedAssemblies,
       _LinkedIntermediateAssembly, and
       _LinkedDebugSymbols. _LinkedResolvedAssemblies needs to keep
       metadata from _ManagedResolvedAssembliesToPublish, since this
       is used by ComputeFilesToPublish. -->
  <Target Name="_ComputeLinkedAssemblies"
          DependsOnTargets="_ComputeManagedResolvedAssembliesToPublish;ILLink">
    <ItemGroup>
      <__LinkedResolvedAssemblies Include="@(_ManagedResolvedAssembliesToPublish->'$(IntermediateLinkDir)/%(Filename)%(Extension)')" />
      <__LinkedResolvedAssemblies Remove="@(_DuplicateManagedAssembliesToSkip->'$(IntermediateLinkDir)/%(Filename)%(Extension)')" />
      <_LinkedResolvedAssemblies Include="@(__LinkedResolvedAssemblies)" Condition="Exists('%(Identity)')" />
    </ItemGroup>

    <ItemGroup>
      <__LinkedIntermediateAssembly Include="@(IntermediateAssembly->'$(IntermediateLinkDir)/%(Filename)%(Extension)')" />
      <_LinkedIntermediateAssembly Include="@(__LinkedIntermediateAssembly)" Condition="Exists('%(Identity)')" />
    </ItemGroup>

    <ItemGroup>
      <__LinkedDebugSymbols Include="@(_DebugSymbolsIntermediatePath->'$(IntermediateLinkDir)/%(Filename)%(Extension)')"
                            Condition=" '$(_DebugSymbolsProduced)' == 'true' " />
      <_LinkedDebugSymbols Include="@(__LinkedDebugSymbols)"
                           Condition="Exists('%(Identity)') And '$(_DebugSymbolsProduced)' == 'true' " />
    </ItemGroup>

  </Target>

  <UsingTask TaskName="SetAssemblyActions" AssemblyFile="$(LinkTaskDllPath)" />
  <Target Name="_SetAssemblyActions"
          DependsOnTargets="_ComputeManagedAssembliesToLink;_ComputePlatformLibraries">

    <ItemGroup>
      <_PlatformAssembliesToLink Include="@(PlatformLibraries->'%(Filename)')" />
      <_ApplicationAssembliesToLink Include="@(_ManagedAssembliesToLink->'%(Filename)')" />
      <_ApplicationAssembliesToLink Remove="@(_PlatformAssembliesToLink)" />
    </ItemGroup>

    <SetAssemblyActions AssemblyPaths="@(_ManagedAssembliesToLink)"
                        ApplicationAssemblyNames="@(_ApplicationAssembliesToLink)"
                        PlatformAssemblyNames="@(_PlatformAssembliesToLink)"
                        UsedApplicationAssemblyAction="$(UsedApplicationAssemblyAction)"
                        UnusedApplicationAssemblyAction="$(UnusedApplicationAssemblyAction)"
                        UsedPlatformAssemblyAction="$(UsedPlatformAssemblyAction)"
                        UnusedPlatformAssemblyAction="$(UnusedPlatformAssemblyAction)">
      <Output TaskParameter="AssemblyPathsWithActions" ItemName="_ManagedAssembliesToLinkWithActions" />
    </SetAssemblyActions>

    <ItemGroup>
      <_ManagedAssembliesToLink Remove="@(_ManagedAssembliesToLink)" />
      <_ManagedAssembliesToLink Include="@(_ManagedAssembliesToLinkWithActions)" />
    </ItemGroup>

  </Target>

  <!-- This calls the linker. Inputs are the managed assemblies to
       link, and root specifications. The semaphore enables msbuild to
       skip linking during an incremental build, when the semaphore is
       up to date with respect to _ManagedAssembliesToLink. -->
  <UsingTask TaskName="ILLink" AssemblyFile="$(LinkTaskDllPath)" />
  <Target Name="ILLink"
          DependsOnTargets="_ComputeManagedAssembliesToLink;_ComputeLinkerRootAssemblies;_ComputeLinkerRootDescriptors;_SetAssemblyActions"
          Inputs="@(_ManagedAssembliesToLink);@(LinkerRootDescriptors);$(MSBuildAllProjects)"
          Outputs="$(_LinkSemaphore)">
    <!-- These extra arguments have been hard-coded for now, as this
         is what we want to use when linking a self-contained app. In
         the future we will want to generate these depending on the
         scenario in which the linker is invoked. -->
    <PropertyGroup>
      <ExtraLinkerArgs Condition=" '$(ExtraLinkerArgs)' == '' ">-t -l none -b true --skip-unresolved true --verbose</ExtraLinkerArgs>
    </PropertyGroup>
    <ILLink AssemblyPaths="@(_ManagedAssembliesToLink)"
            RootAssemblyNames="@(LinkerRootAssemblies)"
            RootDescriptorFiles="@(LinkerRootDescriptors)"
            OutputDirectory="$(IntermediateLinkDir)"
            DumpDependencies="$(LinkerDumpDependencies)"
            ClearInitLocals="$(ClearInitLocals)"
            ClearInitLocalsAssemblies="$(ClearInitLocalsAssemblies)"
            ExtraArgs="$(ExtraLinkerArgs)" />

    <Touch Files="$(_LinkSemaphore)" AlwaysCreate="true">
      <Output TaskParameter="TouchedFiles" ItemName="FileWrites" />
    </Touch>
  </Target>

  <!-- FindNativeDeps scans the managed assemblies kept by the linker
       to find references to native files. It outputs the found native
       dependencies, and these are prevented from being published. -->
  <UsingTask TaskName="FindNativeDeps" AssemblyFile="$(LinkTaskDllPath)" />
  <Target Name="_FindNativeDeps"
          DependsOnTargets="_ComputeLinkedAssemblies;_RemoveDuplicatesFrom_ResolvedCopyLocalPublishAssets"
          Condition=" '$(LinkerTrimNativeDeps)' == 'true' ">
    <ItemGroup>
      <_NativeResolvedDepsToPublish Include="@(_ResolvedCopyLocalPublishAssets)" />
      <_NativeResolvedDepsToPublish Remove="@(_ManagedResolvedAssembliesToPublish)" />
      <_NativeResolvedDepsToPublish Remove="@(_NativeResolvedDepsToPublish->WithMetadataValue('AssetType', 'resources'))" />
    </ItemGroup>

    <ItemGroup>
      <_ManagedLinkedAssemblies Include="@(_LinkedResolvedAssemblies)" />
      <_ManagedLinkedAssemblies Include="@(_LinkedIntermediateAssembly)" />
    </ItemGroup>

    <ItemGroup>
      <_NativeDepsToAlwaysKeep Include="coreclr.dll;libcoreclr.dylib;libcoreclr.so" />
      <_NativeDepsToAlwaysKeep Include="clrjit.dll;libclrjit.dylib;libclrjit.so" />
      <_NativeDepsToAlwaysKeep Include="hostfxr.dll;libhostfxr.dylib;libhostfxr.so" />
      <_NativeDepsToAlwaysKeep Include="hostpolicy.dll;libhostpolicy.dylib;libhostpolicy.so" />
    </ItemGroup>

    <FindNativeDeps ManagedAssemblyPaths="@(_ManagedLinkedAssemblies);@(_DuplicateManagedAssembliesToSkip)"
                    NativeDepsPaths="@(_NativeResolvedDepsToPublish)"
                    NativeDepsToKeep="@(_NativeDepsToAlwaysKeep)">
      <Output TaskParameter="KeptNativeDepsPaths" ItemName="_NativeKeptDepsToPublish" />
    </FindNativeDeps>

  </Target>

  <!-- Computes the managed assemblies that are input to the
       linker. Includes managed assemblies from
       ResolvedAssembliesToPublish, and IntermediateAssembly. -->
  <UsingTask TaskName="FindDuplicatesByMetadata" AssemblyFile="$(LinkTaskDllPath)" />
  <Target Name="_ComputeManagedAssembliesToLink"
          DependsOnTargets="_ComputeManagedResolvedAssembliesToPublish">
    <ItemGroup>
      <_ManagedAssembliesToLink Include="@(IntermediateAssembly)" />
      <_ManagedAssembliesToLink Include="@(_ManagedResolvedAssembliesToPublish)" />
    </ItemGroup>

    <!-- Remove duplicate implementation dlls. This can happen if a
         portable app has platform-specific managed assemblies. The
         linker isn't currently able to analyze multiple assemblies
         with the same identity, so we skip these, keeping only one
         representative assembly from each set of duplicates. -->
    <FindDuplicatesByMetadata Items="@(_ManagedAssembliesToLink)"
                              MetadataName="Filename">
      <Output TaskParameter="DuplicateItems" ItemName="_DuplicateManagedAssemblies" />
      <Output TaskParameter="DuplicateRepresentatives" ItemName="_DuplicateManagedAssembliesToLink" />
    </FindDuplicatesByMetadata>
    <ItemGroup>
      <_DuplicateManagedAssembliesToSkip Include="@(_DuplicateManagedAssemblies)" />
      <_DuplicateManagedAssembliesToSkip Remove="@(_DuplicateManagedAssembliesToLink)" />
      <_ManagedAssembliesToLink Remove="@(_DuplicateManagedAssembliesToSkip)" />
    </ItemGroup>

    <!-- Portable publish: need to supply the linker with any needed
         reference assemblies as well.

         Sometimes assemblies have separate reference and
         implementation assemblies. In these cases, prefer the
         implementation assembly, and prevent inclusion of the ref
         assembly by filtering on filename instead of the full
         path. -->
    <FilterByMetadata Items="@(ReferencePath->'%(ResolvedPath)')"
                      MetadataName="Filename"
                      MetadataValues="@(_ManagedAssembliesToLink->'%(Filename)')"
                      Condition=" '$(SelfContained)' != 'true' ">
      <Output TaskParameter="FilteredItems" ItemName="_ReferencedLibrariesToExclude" />
    </FilterByMetadata>
    <ItemGroup Condition=" '$(SelfContained)' != 'true' ">
      <_ReferencedLibraries Include="@(ReferencePath->'%(ResolvedPath)')" Exclude="@(_ReferencedLibrariesToExclude)" />
      <_ManagedAssembliesToLink Include="@(_ReferencedLibraries)" />
    </ItemGroup>

  </Target>


  <!-- Computes the managed subset of
       ResolvedAssembliesToPublish. This needs to preserve metadata,
       because it is later used to compute the linked assemblies with
       metadata that gets used by the rest of the publish
       pipeline. This needs to run even during incremental build,
       because we use the list of managed assemblies to filter the
       publish output. -->
  <UsingTask TaskName="ComputeManagedAssemblies" AssemblyFile="$(LinkTaskDllPath)" />
  <Target Name="_ComputeManagedResolvedAssembliesToPublish"
          DependsOnTargets="_RemoveDuplicatesFrom_ResolvedCopyLocalPublishAssets">
    <!-- TODO: Is there a better way to get the managed assemblies
         from ResolvedAssembliesToPublish? We may be able to check for
         AssetType="runtime" on managed assemblies - would that give
         the same set of assemblies? -->
    <ComputeManagedAssemblies Assemblies="@(_ResolvedCopyLocalPublishAssets)">
      <Output TaskParameter="ManagedAssemblies" ItemName="_ManagedResolvedAssembliesToPublish" />
    </ComputeManagedAssemblies>
    <!-- For now, hard-code System.Private.CoreLib.ni, the only .ni
         file we've been encountering. This is a special case matching
         how we compute the linker roots by default - we always root
         System.Private.CoreLib, so we want to keep it in the publish
         output and the generated deps.json file. Excluding it from
         _ManagedResolvedAssembliesToPublish will prevent it from
         getting filtered out of the publish output later.

         In the future we may want to detect ngen assemblies and
         filter them more robustly. -->
    <!-- TODO: Which .ni files do we expect to be in
         ResolvedAssembliesToPublish? -->
    <ItemGroup>
      <_ManagedResolvedAssembliesToPublish Remove="@(_ManagedResolvedAssembliesToPublish->WithMetadataValue('Filename', 'System.Private.CoreLib.ni'))" />
    </ItemGroup>
    <!-- Some of the managed dlls are satellite assemblies containing
         binary resources that we don't want to link. -->
    <ItemGroup>
      <_ManagedResolvedAssembliesToPublish Remove="@(_ManagedResolvedAssembliesToPublish->WithMetadataValue('AssetType', 'resources'))" />
    </ItemGroup>
  </Target>


  <!-- Compute the assemblies the linker should mark as roots. By
       default, these are passed as "-a", but this is an
       implementation detail of the link task and should not be relied
       upon in general. In the future we may add other inputs to the
       link task to control how these are rooted.
  -->
  <!-- We may want to add an additional mode in which we root only the
       assembly we have built, rooting all entry points visible from
       the outside of the assembly. We need to discuss whether this
       even makes sense during publish, since typically libraries get
       packaged via "dotnet pack", and the pack task takes input from
       build, not from publish. Thus linking the library itself should
       be part of the build step or pack step, OR pack could be made
       to work on the publish output. -->
  <Target Name="_ComputeLinkerRootAssemblies"
          DependsOnTargets="_ComputeManagedResolvedAssembliesToPublish;_ComputePlatformLibraries;_CheckSystemPrivateCorelibEmbeddedRoots">
    <!-- If RootAllApplicationAssemblies is true, roots are everything
         minus the framework assemblies. This doesn't include the
         intermediate assembly, because we root it separately using an
         xml file, which lets us explicitly root everything.

         If RootAllApplicationAssemblies is false, only intermediate
         assembly's Main method is rooted.

         System.Private.CoreLib is rooted unless it has an embedded
         xml descriptor file. -->

    <ItemGroup Condition=" '$(RootAllApplicationAssemblies)' == 'true' ">
      <_LinkerRootAssemblies Include="@(_ManagedResolvedAssembliesToPublish->'%(Filename)')" />
      <_LinkerRootAssemblies Remove="@(PlatformLibraries->'%(Filename)')" />
    </ItemGroup>
    <RemoveDuplicates Inputs="@(_LinkerRootAssemblies)"
                      Condition=" '$(RootAllApplicationAssemblies)' == 'true' ">
      <Output TaskParameter="Filtered" ItemName="_UniqueLinkerRootAssemblies" />
    </RemoveDuplicates>
    <ItemGroup Condition=" '$(RootAllApplicationAssemblies)' == 'true' ">
      <LinkerRootAssemblies Include="@(_UniqueLinkerRootAssemblies)" />
    </ItemGroup>

    <ItemGroup Condition=" '$(RootAllApplicationAssemblies)' == 'false' ">
      <LinkerRootAssemblies Include="@(IntermediateAssembly)" />
    </ItemGroup>

    <ItemGroup Condition=" '$(_SPCHasEmbeddedRootDescriptor)' != 'true' ">
      <LinkerRootAssemblies Include="@(_ManagedResolvedAssembliesToPublish->'%(Filename)')" Condition=" '%(Filename)' == 'System.Private.CoreLib' " />
    </ItemGroup>

  </Target>

  <UsingTask TaskName="CheckEmbeddedRootDescriptor" AssemblyFile="$(LinkTaskDllPath)" />
  <Target Name="_CheckSystemPrivateCorelibEmbeddedRoots" Condition=" '$(SelfContained)' == 'true' "
          DependsOnTargets="_ComputeManagedAssembliesToLink">
    <CheckEmbeddedRootDescriptor AssemblyPath="@(_ManagedAssembliesToLink->WithMetadataValue('Filename', 'System.Private.CoreLib'))">
      <Output TaskParameter="HasEmbeddedRootDescriptor" PropertyName="_SPCHasEmbeddedRootDescriptor" />
    </CheckEmbeddedRootDescriptor>
  </Target>

  <!-- Platform libraries are the managed runtime assets needed by the
       "platform", currently Microsoft.NETCore.App. -->
  <UsingTask TaskName="GetRuntimeLibraries" AssemblyFile="$(LinkTaskDllPath)" />
  <Target Name="_ComputePlatformLibraries"
          DependsOnTargets="_ComputeManagedAssembliesToLink;ResolveRuntimePackAssets">

    <ItemGroup>
      <PlatformLibraries Include="@(RuntimePackAssets)" />
    </ItemGroup>

    <ItemGroup>
      <PlatformLibraries Include="@(_ManagedAssembliesToLink)" Condition=" '%(Filename)' == 'System.Private.CoreLib' " />
    </ItemGroup>

    <ItemGroup Condition=" '$(SelfContained)' != 'true' ">
      <!-- Portable publish: computed referenced-not-published set in _ComputeManagedAssembliesToLink -->
      <PlatformLibraries Include="@(_ReferencedLibraries)" />
    </ItemGroup>
  </Target>


  <!-- This target prepares the LinkerRootDescriptors itemgroup for
       input to the link task. In addition to including user-specified
       LinkerRootDescriptors in the ItemGroup statically above, we
       dynamically include the generated descriptor files for the
       intermediate assembly. -->
  <Target Name="_ComputeLinkerRootDescriptors"
          DependsOnTargets="_GenerateIntermediateRootDescriptor"
          Condition=" '$(RootAllApplicationAssemblies)' == 'true' ">
    <ItemGroup>
      <LinkerRootDescriptors Include="$(_IntermediateRootDescriptorPath)" />
    </ItemGroup>
  </Target>


  <!-- Generates the xml root descriptor file that completely roots
       the intermediate assembly. -->
  <UsingTask TaskName="CreateRootDescriptorFile" AssemblyFile="$(LinkTaskDllPath)" />
  <Target Name="_GenerateIntermediateRootDescriptor"
          Inputs="@(IntermediateAssembly)"
          Outputs="$(_IntermediateRootDescriptorPath)"
          Condition=" '$(RootAllApplicationAssemblies)' == 'true' ">
    <CreateRootDescriptorFile AssemblyNames="@(IntermediateAssembly->'%(Filename)')"
                              RootDescriptorFilePath="$(_IntermediateRootDescriptorPath)" />
  </Target>

  <!-- Uses _PublishConflictPackageFiles, an input to the publish deps
       file generation target, to exclude the removed managed
       assemblies and native dependencies from the generated deps
       file. -->
  <UsingTask TaskName="ComputeRemovedAssemblies" AssemblyFile="$(LinkTaskDllPath)" />
  <Target Name="_ExcludeRemovedFilesFromDepFileGeneration"
          DependsOnTargets="_ComputeManagedResolvedAssembliesToPublish;_ComputeLinkedAssemblies;_FindNativeDeps;_HandlePackageFileConflictsForPublish"
          BeforeTargets="GeneratePublishDependencyFile"
          Condition=" '$(LinkDuringPublish)' == 'true' ">
    <ComputeRemovedAssemblies InputAssemblies="@(_ManagedAssembliesToLink)"
                              KeptAssemblies="@(_LinkedResolvedAssemblies)">
      <Output TaskParameter="RemovedAssemblies" ItemName="_RemovedManagedAssemblies" />
    </ComputeRemovedAssemblies>

    <ItemGroup>
      <_RemovedNativeDeps Include="@(_NativeResolvedDepsToPublish)" />
      <_RemovedNativeDeps Remove="@(_NativeKeptDepsToPublish)" />

      <_PublishConflictPackageFiles Include="@(_RemovedManagedAssemblies)" />
      <_PublishConflictPackageFiles Include="@(_RemovedNativeDeps)" />
    </ItemGroup>
  </Target>

</Project>