mono/linux-packaging-mono
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Imported Upstream version 5.14.0.78

Browse Source 
Former-commit-id: 3494343bcc9ddb42b36b82dd9ae7b69e85e0229f
This commit is contained in:
Xamarin Public Jenkins (auto-signing)
2018-05-10 08:37:03 +00:00
parent 74b74abd9f
commit 19234507ba
1776 changed files with 67755 additions and 31107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
external/linker/corebuild/integration/ILLink.Tasks/ComputeReadyToRunAssemblies.cs → external/linker/corebuild/integration/ILLink.Tasks/ComputeCrossgenedAssemblies.cs vendored
View File

@@ -4,7 +4,7 @@ using Microsoft.Build.Utilities;
namespace ILLink.Tasks
{
public class ComputeReadyToRunAssemblies : Task
public class ComputeCrossgenedAssemblies : Task
{
/// <summary>
/// Paths to assemblies.
@@ -13,17 +13,17 @@ namespace ILLink.Tasks
public ITaskItem[] Assemblies { get; set; }
/// <summary>
/// This will contain the output list of
/// ready-to-run assemblies. Metadata from the input
/// parameter Assemblies is preserved.
/// This will contain the output list of crossgen-ed
/// assemblies. Metadata from the input parameter
/// Assemblies is preserved.
/// </summary>
[Output]
public ITaskItem[] ReadyToRunAssemblies { get; set; }
public ITaskItem[] CrossgenedAssemblies { get; set; }
public override bool Execute()
{
ReadyToRunAssemblies = Assemblies
.Where(f => Utils.IsReadyToRunAssembly(f.ItemSpec))
CrossgenedAssemblies = Assemblies
.Where(f => Utils.IsCrossgenedAssembly(f.ItemSpec))
.ToArray();
return true;
}

79
external/linker/corebuild/integration/ILLink.Tasks/CreateRuntimeRootDescriptorFile.cs vendored
View File

@@ -33,6 +33,12 @@ namespace ILLink.Tasks
[Required]
public ITaskItem RexcepFilePath { get; set; }
/// <summary>
/// The path to ILLinkTrim.xml.
/// </summary>
[Required]
public ITaskItem ILLinkTrimXmlFilePath { get; set; }
/// <summary>
/// The path to the file to generate.
/// </summary>
@@ -76,6 +82,12 @@ namespace ILLink.Tasks
return false;
}
var iLLinkTrimXmlFilePath = ILLinkTrimXmlFilePath.ItemSpec;
if (!File.Exists (iLLinkTrimXmlFilePath)) {
Log.LogError ("File " + iLLinkTrimXmlFilePath + " doesn't exist.");
return false;
}
ProcessNamespaces (namespaceFilePath);
ProcessMscorlib (mscorlibFilePath);
@@ -84,7 +96,7 @@ namespace ILLink.Tasks
ProcessExceptionTypes (rexcepFilePath);
OutputXml (RuntimeRootDescriptorFilePath.ItemSpec);
OutputXml (iLLinkTrimXmlFilePath, RuntimeRootDescriptorFilePath.ItemSpec);
return true;
}
@@ -206,22 +218,17 @@ namespace ILLink.Tasks
string classNamespace = defElements [1]; // g_InteropNS
string className = defElements [2]; // MarshalDirectiveException
AddClass (classNamespace, className, classId);
AddMethod (".ctor", classId, classNamespace, className);
}
}
}
void OutputXml (string outputFileName)
void OutputXml (string iLLinkTrimXmlFilePath, string outputFileName)
{
XmlDocument doc = new XmlDocument ();
XmlNode linkerNode = doc.CreateElement ("linker");
doc.AppendChild (linkerNode);
XmlNode assemblyNode = doc.CreateElement ("assembly");
XmlAttribute assemblyFullName = doc.CreateAttribute ("fullname");
assemblyFullName.Value = "System.Private.CoreLib";
assemblyNode.Attributes.Append (assemblyFullName);
linkerNode.AppendChild (assemblyNode);
doc.Load (iLLinkTrimXmlFilePath);
XmlNode linkerNode = doc ["linker"];
XmlNode assemblyNode = linkerNode ["assembly"];
foreach (string typeName in classNamesToClassMembers.Keys) {
XmlNode typeNode = doc.CreateElement ("type");
@@ -273,20 +280,8 @@ namespace ILLink.Tasks
void AddClass (string classNamespace, string className, string classId, bool keepAllFields = false)
{
string prefixToRemove = "g_";
if (classNamespace.StartsWith (prefixToRemove)) {
classNamespace = classNamespace.Substring (prefixToRemove.Length);
}
string suffixToRemove = "NS";
if (classNamespace.EndsWith (suffixToRemove)) {
classNamespace = classNamespace.Substring (0, classNamespace.Length - suffixToRemove.Length);
}
string fullClassName = null;
if ((classNamespace != "NULL") && (className != "NULL")) {
if (!namespaceDictionary.ContainsKey (classNamespace)) {
Log.LogError ("Unknown namespace: " + classNamespace);
}
fullClassName = namespaceDictionary [classNamespace] + "." + className;
string fullClassName = GetFullClassName (classNamespace, className);
if (fullClassName != null) {
if ((classId != null) && (classId != "NoClass")) {
classIdsToClassNames [classId] = fullClassName;
}
@@ -311,16 +306,44 @@ namespace ILLink.Tasks
members.fields.Add (fieldName);
}
void AddMethod (string methodName, string classId)
void AddMethod (string methodName, string classId, string classNamespace = null, string className = null)
{
string className = classIdsToClassNames [classId];
string fullClassName;
if (classId != null) {
fullClassName = classIdsToClassNames [classId];
}
else {
fullClassName = GetFullClassName (classNamespace, className);
}
ClassMembers members = classNamesToClassMembers [className];
ClassMembers members = classNamesToClassMembers [fullClassName];
if (members.methods == null) {
members.methods = new HashSet<string> ();
}
members.methods.Add (methodName);
}
string GetFullClassName (string classNamespace, string className)
{
string prefixToRemove = "g_";
if (classNamespace.StartsWith (prefixToRemove)) {
classNamespace = classNamespace.Substring (prefixToRemove.Length);
}
string suffixToRemove = "NS";
if (classNamespace.EndsWith (suffixToRemove)) {
classNamespace = classNamespace.Substring (0, classNamespace.Length - suffixToRemove.Length);
}
if ((classNamespace == "NULL") && (className == "NULL")) {
return null;
}
if (!namespaceDictionary.ContainsKey (classNamespace)) {
Log.LogError ("Unknown namespace: " + classNamespace);
}
return namespaceDictionary [classNamespace] + "." + className;
}
}
}

47
external/linker/corebuild/integration/ILLink.Tasks/FindDuplicatesByMetadata.cs vendored Normal file
View File

@@ -0,0 +1,47 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;
namespace ILLink.Tasks
{
public class FindDuplicatesByMetadata : Task
{
/// <summary>
/// Items to scan.
/// </summary>
[Required]
public ITaskItem [] Items { get; set; }
/// <summary>
/// Name of metadata to scan for.
/// </summary>
[Required]
public String MetadataName { get; set; }
/// <summary>
/// Duplicate items: the input items for which the
/// specified metadata was shared by multiple input
/// items.
/// </summary>
[Output]
public ITaskItem [] DuplicateItems { get; set; }
/// <summary>
/// Duplicate representatives: includes one input
/// item from each set of duplicates.
/// </summary>
[Output]
public ITaskItem [] DuplicateRepresentatives { get; set; }
public override bool Execute ()
{
var duplicateGroups = Items.GroupBy (i => i.GetMetadata (MetadataName))
.Where (g => g.Count () > 1);
DuplicateItems = duplicateGroups.SelectMany (g => g).ToArray ();
DuplicateRepresentatives = duplicateGroups.Select (g => g.First ()).ToArray ();
return true;
}
}
}

26
external/linker/corebuild/integration/ILLink.Tasks/ILLink.CrossGen.targets vendored
View File

@@ -1,7 +1,7 @@
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<CrossGenDuringPublish Condition=" '$(CrossGenDuringPublish)' == '' And '$(RuntimeIdentifier)' != '' ">true</CrossGenDuringPublish>
<CrossGenDuringPublish Condition=" '$(CrossGenDuringPublish)' == '' And '$(RuntimeIdentifier)' != '' And '$(LinkDuringPublish)' == 'true' ">true</CrossGenDuringPublish>
</PropertyGroup>
<PropertyGroup>
@@ -28,8 +28,7 @@
<ItemGroup>
<_CrossGenResolvedAssembliesToPublishCandidates Include="@(ResolvedAssembliesToPublish->'$(IntermediateOptimizedDir)/%(Filename)%(Extension)')" />
<_CrossGenResolvedAssembliesToPublish Include="@(_CrossGenResolvedAssembliesToPublishCandidates)" Condition="Exists('%(Identity)')" />
<!-- FilesToCrossGen doesn't contain System.Private.CoreLib, so
it will still be published. -->
<ResolvedAssembliesToPublish Remove="@(FilesToCrossGen)" />
<ResolvedAssembliesToPublish Include="@(_CrossGenResolvedAssembliesToPublish)" />
</ItemGroup>
@@ -188,9 +187,9 @@
<UsingTask TaskName="FilterByMetadata" AssemblyFile="$(LinkTaskDllPath)" />
<!-- This computes the default set of files that we want to be
crossgen'd. Some of these may already be R2R images, and these
will not be crossgen'd again. The default is to crossgen the
app and platform libraries. Defaults will be used only if
crossgen'd. Some of these may already be crossgen images, and
these will not be crossgen'd again. The default is to crossgen
the app and platform libraries. Defaults will be used only if
FilesToCrossGen hasn't been set elsewhere, allowing users and
other props/targets to select what will be crossgen'd. -->
<Target Name="_ComputeDefaultFilesToCrossGen"
@@ -208,21 +207,20 @@
<FilesToCrossGen Include="@(_PlatformLibrariesForCrossGen)" />
</ItemGroup>
<Error Text="System.Private.CoreLib should already be crossgen compiled."
Condition=" '%(FilesToCrossGen.Filename)' == 'System.Private.CoreLib' " />
</Target>
<UsingTask TaskName="ComputeReadyToRunAssemblies" AssemblyFile="$(LinkTaskDllPath)" />
<UsingTask TaskName="ComputeCrossgenedAssemblies" AssemblyFile="$(LinkTaskDllPath)" />
<Target Name="_ComputeFilesToCrossGen"
DependsOnTargets="_ComputeDefaultFilesToCrossGen">
<ComputeReadyToRunAssemblies Assemblies="@(FilesToCrossGen)">
<Output TaskParameter="ReadyToRunAssemblies" ItemName="_ReadyToRunFiles" />
</ComputeReadyToRunAssemblies>
<ComputeCrossgenedAssemblies Assemblies="@(FilesToCrossGen)">
<Output TaskParameter="CrossgenedAssemblies" ItemName="_CrossgenedFiles" />
</ComputeCrossgenedAssemblies>
<!-- Don't try to run crossgen on assemblies that are already R2R. -->
<!-- Don't try to run crossgen on assemblies that are already
crossgen'd. -->
<ItemGroup>
<FilesToCrossGen Remove="@(_ReadyToRunFiles)" />
<FilesToCrossGen Remove="@(_CrossgenedFiles)" />
</ItemGroup>
<Message Text="files to crossgen: @(FilesToCrossGen)" />

5
external/linker/corebuild/integration/ILLink.Tasks/ILLink.Tasks.csproj vendored
View File

@@ -1,6 +1,6 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<VersionPrefix>0.1.4-preview</VersionPrefix>
<VersionPrefix>0.1.5-preview</VersionPrefix>
<TargetFrameworks>netcoreapp2.0;net46</TargetFrameworks>
<TargetFrameworks Condition=" '$(OS)' != 'Windows_NT' ">netcoreapp2.0</TargetFrameworks>
<EnableDefaultCompileItems>false</EnableDefaultCompileItems>
@@ -101,11 +101,12 @@
<Compile Include="LinkTask.cs" />
<Compile Include="CompareSizes.cs" />
<Compile Include="ComputeManagedAssemblies.cs" />
<Compile Include="ComputeReadyToRunAssemblies.cs" />
<Compile Include="ComputeCrossgenedAssemblies.cs" />
<Compile Include="GetRuntimeLibraries.cs" />
<Compile Include="CreateRootDescriptorFile.cs" />
<Compile Include="CreateRuntimeRootDescriptorFile.cs" />
<Compile Include="FilterByMetadata.cs" />
<Compile Include="FindDuplicatesByMetadata.cs" />
<Compile Include="Utils.cs" />
<Compile Include="Microsoft.NET.Build.Tasks/LockFileCache.cs" />
<Compile Include="Microsoft.NET.Build.Tasks/BuildErrorException.cs" />

134
external/linker/corebuild/integration/ILLink.Tasks/ILLink.Tasks.targets vendored
View File

@@ -95,7 +95,7 @@
<!-- Rewrite ResolvedAssembliesToPublish, which is an input to
ComputeFilesToPublish. -->
<ItemGroup>
<ResolvedAssembliesToPublish Remove="@(_ManagedResolvedAssembliesToPublish)" />
<ResolvedAssembliesToPublish Remove="@(_ManagedAssembliesToLink)" />
<ResolvedAssembliesToPublish Remove="@(_NativeResolvedDepsToPublish)" />
<ResolvedAssembliesToPublish Include="@(_NativeKeptDepsToPublish)" />
<ResolvedAssembliesToPublish Include="@(_LinkedResolvedAssemblies)" />
@@ -145,15 +145,21 @@
<!-- 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 top-level link target, ComputeLinkedFilesToPublish, so it
is output even during incremental builds. -->
the ComputeFilesToPublish, so it is output even during
incremental builds and takes into account all transformations
on the files to be published, including link and crossgen. -->
<UsingTask TaskName="CompareAssemblySizes" AssemblyFile="$(LinkTaskDllPath)" />
<Target Name="_CompareLinkedAssemblySizes"
AfterTargets="ComputeLinkedFilesToPublish"
AfterTargets="ComputeFilesToPublish"
DependsOnTargets="_ComputeManagedAssembliesToLink;_ComputeLinkedAssemblies"
Condition=" '$(LinkDuringPublish)' == 'true' And '$(ShowLinkerSizeComparison)' == 'true' ">
<FilterByMetadata Items="@(ResolvedAssembliesToPublish);@(IntermediateAssembly)"
MetadataName="Filename"
MetadataValues="@(_ManagedAssembliesToLink->'%(Filename)')">
<Output TaskParameter="FilteredItems" ItemName="_FinalAssembliesTouchedByLinker" />
</FilterByMetadata>
<CompareAssemblySizes UnlinkedAssemblies="@(_ManagedAssembliesToLink)"
LinkedAssemblies="@(_LinkedIntermediateAssembly);@(_LinkedResolvedAssemblies)" />
LinkedAssemblies="@(_FinalAssembliesTouchedByLinker)" />
</Target>
@@ -166,9 +172,10 @@
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)')" />
@@ -180,33 +187,62 @@
<_LinkedDebugSymbols Include="@(__LinkedDebugSymbols)"
Condition="Exists('%(Identity)') And '$(_DebugSymbolsProduced)' == 'true' " />
</ItemGroup>
</Target>
<!-- Compute the default set of assemblies to crossgen after
linking. This will include any assemblies modified by the
linker that were crossgen'd before linking. -->
<Target Name="_ComputeLinkedAssembliesToCrossgen"
AfterTargets="_ComputeLinkedAssemblies"
Condition=" '$(CrossGenDuringPublish)' == 'true' ">
<FilterByMetadata Items="@(_ManagedResolvedAssembliesToPublish);@(IntermediateAssembly)"
MetadataName="Filename"
MetadataValues="@(_LinkedResolvedAssemblies->'%(Filename)');@(_LinkedIntermediateAssembly->'%(Filename)')">
<Output TaskParameter="FilteredItems" ItemName="_OriginalLinkedAssemblies" />
</FilterByMetadata>
<ComputeCrossgenedAssemblies Assemblies="@(_OriginalLinkedAssemblies)">
<Output TaskParameter="CrossgenedAssemblies" ItemName="_OriginalLinkedAssembliesThatWereCrossgened" />
</ComputeCrossgenedAssemblies>
<!-- Ideally, we would remember which assemblies were R2R and
which were fragile crossgen-ed, and do the same after
linking. Currently this makes no difference because
System.Private.CoreLib is the only fragile image, and it
can't be ready-to-run crossgen-ed. -->
<ItemGroup>
<_LinkedAssembliesToCrossgen Include="@(_OriginalLinkedAssembliesThatWereCrossgened->'$(IntermediateLinkDir)/%(Filename)%(Extension)')" />
<FilesToCrossgen Include="@(_LinkedAssembliesToCrossgen)" />
</ItemGroup>
</Target>
<UsingTask TaskName="SetAssemblyActions" AssemblyFile="$(LinkTaskDllPath)" />
<Target Name="_SetAssemblyActions"
DependsOnTargets="_ComputeManagedAssembliesToLink;_ComputePlatformLibraries">
<ItemGroup>
<_PlatformAssembliesToLink Include="@(PlatformLibraries->'%(Filename)')" />
<_PlatformAssembliesToLink Include="System.Private.CoreLib" />
<_ApplicationAssembliesToLink Include="@(_ManagedAssembliesToLink->'%(Filename)')" />
<_ApplicationAssembliesToLink Remove="@(_PlatformAssembliesToLink)" />
</ItemGroup>
<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>
<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>
<ItemGroup>
<_ManagedAssembliesToLink Remove="@(_ManagedAssembliesToLink)" />
<_ManagedAssembliesToLink Include="@(_ManagedAssembliesToLinkWithActions)" />
</ItemGroup>
</Target>
<!-- This calls the linker. Inputs are the managed assemblies to
@@ -244,7 +280,8 @@
dependencies, and these are prevented from being published. -->
<UsingTask TaskName="FindNativeDeps" AssemblyFile="$(LinkTaskDllPath)" />
<Target Name="_FindNativeDeps"
DependsOnTargets="_ComputeLinkedAssemblies">
DependsOnTargets="_ComputeLinkedAssemblies"
Condition=" '$(LinkerTrimNativeDeps)' == 'true' ">
<ItemGroup>
<_NativeResolvedDepsToPublish Include="@(ResolvedAssembliesToPublish)" />
<_NativeResolvedDepsToPublish Remove="@(_ManagedResolvedAssembliesToPublish)" />
@@ -263,21 +300,18 @@
<_NativeDepsToAlwaysKeep Include="hostpolicy.dll;libhostpolicy.dylib;libhostpolicy.so" />
</ItemGroup>
<FindNativeDeps Condition=" '$(LinkerTrimNativeDeps)' == 'true' "
ManagedAssemblyPaths="@(_ManagedLinkedAssemblies)"
<FindNativeDeps ManagedAssemblyPaths="@(_ManagedLinkedAssemblies);@(_DuplicateManagedAssembliesToSkip)"
NativeDepsPaths="@(_NativeResolvedDepsToPublish)"
NativeDepsToKeep="@(_NativeDepsToAlwaysKeep)">
<Output TaskParameter="KeptNativeDepsPaths" ItemName="_NativeKeptDepsToPublish" />
</FindNativeDeps>
<PropertyGroup>
<_NativeKeptDepsToPublish Condition=" '$(LinkerTrimNativeDeps)' != 'true' ">"@(_NativeResolvedDepsToPublish)"</_NativeKeptDepsToPublish>
</PropertyGroup>
</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>
@@ -285,6 +319,22 @@
<_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.
@@ -376,14 +426,23 @@
<ItemGroup Condition=" '$(RootAllApplicationAssemblies)' == 'true' ">
<_LinkerRootAssemblies Include="@(_ManagedResolvedAssembliesToPublish->'%(Filename)')" />
<_LinkerRootAssemblies Remove="@(PlatformLibraries->'%(Filename)')" />
<_LinkerRootAssemblies Remove="System.Private.CoreLib" Condition=" '$(_SPCHasEmbeddedRootDescriptor)' == 'true' "/>
<LinkerRootAssemblies Include="@(_LinkerRootAssemblies)" />
</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)" />
<LinkerRootAssemblies Include="System.Private.CoreLib" Condition=" '$(_SPCHasEmbeddedRootDescriptor)' == 'false' "/>
</ItemGroup>
<ItemGroup Condition=" '$(_SPCHasEmbeddedRootDescriptor)' != 'true' ">
<LinkerRootAssemblies Include="@(_ManagedResolvedAssembliesToPublish->'%(Filename)')" Condition=" '%(Filename)' == 'System.Private.CoreLib' " />
</ItemGroup>
</Target>
<UsingTask TaskName="CheckEmbeddedRootDescriptor" AssemblyFile="$(LinkTaskDllPath)" />
@@ -406,6 +465,11 @@
PackageNames="$(MicrosoftNETPlatformLibrary)">
<Output TaskParameter="RuntimeLibraries" ItemName="PlatformLibraries" />
</GetRuntimeLibraries>
<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)" />
@@ -447,7 +511,7 @@
DependsOnTargets="_ComputeManagedResolvedAssembliesToPublish;_ComputeLinkedAssemblies;_FindNativeDeps;_HandlePublishFileConflicts"
BeforeTargets="GeneratePublishDependencyFile"
Condition=" '$(LinkDuringPublish)' == 'true' ">
<ComputeRemovedAssemblies InputAssemblies="@(_ManagedResolvedAssembliesToPublish)"
<ComputeRemovedAssemblies InputAssemblies="@(_ManagedAssembliesToLink)"
KeptAssemblies="@(_LinkedResolvedAssemblies)">
<Output TaskParameter="RemovedAssemblies" ItemName="_RemovedManagedAssemblies" />
</ComputeRemovedAssemblies>

3
external/linker/corebuild/integration/ILLink.Tasks/LinkTask.cs vendored
View File

@@ -16,6 +16,9 @@ namespace ILLink.Tasks
/// behavior should not be relied upon. Instead, work under
/// the assumption that only the AssemblyPaths given will be
/// resolved.
/// Each path can also have an "action" metadata,
/// which will set the illink action to take for
/// that assembly.
/// </summary>
[Required]
public ITaskItem [] AssemblyPaths { get; set; }

8
external/linker/corebuild/integration/ILLink.Tasks/Utils.cs vendored
View File

@@ -1,7 +1,8 @@
using System;
using Mono.Cecil;
using Mono.Linker;
public class Utils
public static class Utils
{
public static bool IsManagedAssembly (string fileName)
{
@@ -13,12 +14,11 @@ public class Utils
}
}
public static bool IsReadyToRunAssembly (string fileName)
public static bool IsCrossgenedAssembly (string fileName)
{
try {
ModuleDefinition module = ModuleDefinition.ReadModule (fileName);
return (module.Attributes & ModuleAttributes.ILOnly) == 0 &&
(module.Attributes & (ModuleAttributes) 0x04) != 0;
return module.IsCrossgened ();
} catch (BadImageFormatException) {
return false;
}