Make default rooting behavior consistent (dotnet#3124)

Now specifying an assembly as a root without any other qualifiers will default to rooting everything.

Commit migrated from dotnet@e775974

src/tools/illink/src/linker/Linker.Steps/RootAssemblyInputStep.cs

@@ -0,0 +1,202 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.IO;
+using ILLink.Shared;
+using Mono.Cecil;
+
+namespace Mono.Linker.Steps
+{
+ public class RootAssemblyInput : BaseStep
+ {
+ readonly string fileName;
+ readonly AssemblyRootMode rootMode;
+
+ public RootAssemblyInput (string fileName, AssemblyRootMode rootMode)
+ {
+ this.fileName = fileName;
+ this.rootMode = rootMode;
+ }
+
+ protected override void Process ()
+ {
+ AssemblyDefinition? assembly = LoadAssemblyFile ();
+ if (assembly == null)
+ return;
+
+ var di = new DependencyInfo (DependencyKind.RootAssembly, assembly);
+ var origin = new MessageOrigin (assembly);
+
+ AssemblyAction action = Context.Annotations.GetAction (assembly);
+ switch (action) {
+ case AssemblyAction.Copy:
+ Annotations.Mark (assembly.MainModule, di, origin);
+ // Mark Step will take care of marking whole assembly
+ return;
+ case AssemblyAction.CopyUsed:
+ case AssemblyAction.Link:
+ break;
+ default:
+ Context.LogError (null, DiagnosticId.RootAssemblyCannotUseAction, assembly.Name.ToString (), action.ToString ());
+ return;
+ }
+
+ switch (rootMode) {
+ case AssemblyRootMode.EntryPoint:
+ var ep = assembly.MainModule.EntryPoint;
+ if (ep == null) {
+ Context.LogError (null, DiagnosticId.RootAssemblyDoesNotHaveEntryPoint, assembly.Name.ToString ());
+ return;
+ }
+
+ Annotations.Mark (ep.DeclaringType, di, origin);
+ Annotations.AddPreservedMethod (ep.DeclaringType, ep);
+ break;
+ case AssemblyRootMode.VisibleMembers:
+ var preserve_visible = TypePreserveMembers.Visible;
+ if (MarkInternalsVisibleTo (assembly))
+ preserve_visible |= TypePreserveMembers.Internal;
+
+ MarkAndPreserve (assembly, preserve_visible);
+ break;
+
+ case AssemblyRootMode.Library:
+ var preserve_library = TypePreserveMembers.Visible | TypePreserveMembers.Library;
+ if (MarkInternalsVisibleTo (assembly))
+ preserve_library |= TypePreserveMembers.Internal;
+
+ MarkAndPreserve (assembly, preserve_library);
+
+ // Assembly root mode wins over any enabled optimization which
+ // could conflict with library rooting behaviour
+ Context.Optimizations.Disable (
+ CodeOptimizations.Sealer |
+ CodeOptimizations.UnusedTypeChecks |
+ CodeOptimizations.UnreachableBodies |
+ CodeOptimizations.UnusedInterfaces |
+ CodeOptimizations.RemoveDescriptors |
+ CodeOptimizations.RemoveLinkAttributes |
+ CodeOptimizations.RemoveSubstitutions |
+ CodeOptimizations.RemoveDynamicDependencyAttribute |
+ CodeOptimizations.OptimizeTypeHierarchyAnnotations, assembly.Name.Name);
+
+ // Enable EventSource special handling
+ Context.DisableEventSourceSpecialHandling = false;
+
+ // No metadata trimming
+ Context.MetadataTrimming = MetadataTrimming.None;
+ break;
+ case AssemblyRootMode.AllMembers:
+ Context.Annotations.SetAction (assembly, AssemblyAction.Copy);
+ return;
+ }
+ }
+
+ AssemblyDefinition? LoadAssemblyFile ()
+ {
+ AssemblyDefinition? assembly;
+
+ if (File.Exists (fileName)) {
+ assembly = Context.Resolver.GetAssembly (fileName);
+ AssemblyDefinition? loaded = Context.GetLoadedAssembly (assembly.Name.Name);
+
+ // The same assembly could be already loaded if there are multiple inputs pointing to same file
+ if (loaded != null)
+ return loaded;
+
+ Context.Resolver.CacheAssembly (assembly);
+ return assembly;
+ }
+
+ //
+ // Quirks mode for netcore to support passing ambiguous assembly name
+ //
+ assembly = Context.TryResolve (fileName);
+ if (assembly == null)
+ Context.LogError (null, DiagnosticId.RootAssemblyCouldNotBeFound, fileName);
+
+ return assembly;
+ }
+
+ void MarkAndPreserve (AssemblyDefinition assembly, TypePreserveMembers preserve)
+ {
+ var module = assembly.MainModule;
+ if (module.HasExportedTypes)
+ foreach (var type in module.ExportedTypes)
+ MarkAndPreserve (assembly, type, preserve);
+
+ foreach (var type in module.Types)
+ MarkAndPreserve (type, preserve);
+ }
+
+ void MarkAndPreserve (TypeDefinition type, TypePreserveMembers preserve)
+ {
+ TypePreserveMembers preserve_anything = preserve;
+ if ((preserve & TypePreserveMembers.Visible) != 0 && !IsTypeVisible (type))
+ preserve_anything &= ~TypePreserveMembers.Visible;
+
+ if ((preserve & TypePreserveMembers.Internal) != 0 && IsTypePrivate (type))
+ preserve_anything &= ~TypePreserveMembers.Internal;
+
+ // Keep all interfaces and interface members in library mode
+ if ((preserve & TypePreserveMembers.Library) != 0 && type.IsInterface) {
+ Annotations.Mark (type, new DependencyInfo (DependencyKind.RootAssembly, type.Module.Assembly), new MessageOrigin (type.Module.Assembly));
+ Annotations.SetPreserve (type, TypePreserve.All);
+ }
+
+ switch (preserve_anything) {
+ case 0:
+ return;
+ case TypePreserveMembers.Library:
+ //
+ // In library mode private type can have members kept for serialization if
+ // the type is referenced
+ //
+ preserve = preserve_anything;
+ Annotations.SetMembersPreserve (type, preserve);
+ break;
+ default:
+ Annotations.Mark (type, new DependencyInfo (DependencyKind.RootAssembly, type.Module.Assembly), new MessageOrigin (type.Module.Assembly));
+ Annotations.SetMembersPreserve (type, preserve);
+ break;
+ }
+
+ if (!type.HasNestedTypes)
+ return;
+
+ foreach (TypeDefinition nested in type.NestedTypes)
+ MarkAndPreserve (nested, preserve);
+ }
+
+ void MarkAndPreserve (AssemblyDefinition assembly, ExportedType type, TypePreserveMembers preserve)
+ {
+ var di = new DependencyInfo (DependencyKind.RootAssembly, assembly);
+ var origin = new MessageOrigin (assembly);
+ Context.Annotations.Mark (type, di, origin);
+ Context.Annotations.Mark (assembly.MainModule, di, origin);
+ Annotations.SetMembersPreserve (type, preserve);
+ }
+
+ static bool IsTypeVisible (TypeDefinition type)
+ {
+ return type.IsPublic || type.IsNestedPublic || type.IsNestedFamily || type.IsNestedFamilyOrAssembly;
+ }
+
+ static bool IsTypePrivate (TypeDefinition type)
+ {
+ return type.IsNestedPrivate;
+ }
+
+ bool MarkInternalsVisibleTo (AssemblyDefinition assembly)
+ {
+ foreach (CustomAttribute attribute in assembly.CustomAttributes) {
+ if (attribute.Constructor.DeclaringType.IsTypeOf ("System.Runtime.CompilerServices", "InternalsVisibleToAttribute")) {
+ Context.Annotations.Mark (attribute, new DependencyInfo (DependencyKind.RootAssembly, assembly));
+ return true;
+ }
+ }
+
+ return false;
+ }
+ }
+}

src/tools/illink/src/linker/Linker/AssemblyRootMode.cs

@@ -0,0 +1,13 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Mono.Linker
+{
+ public enum AssemblyRootMode
+ {
+ AllMembers = 0,
+ EntryPoint,
+ VisibleMembers,
+ Library
+ }
+}