StardewValley
/
SMAPI
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

reduce unneeded operations when scanning/rewriting mod DLLs

This commit is contained in:
Jesse Plamondon-Willard 2021-08-31 01:13:22 -04:00
parent c6cc1513c5
commit 8bfab94213
No known key found for this signature in database
GPG Key ID: CF8B1456B3E29F49
11 changed files with 155 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
docs/release-notes.md
View File

@ -4,6 +4,7 @@
## Upcoming release
* For players:
* Improved mod compatibility in 64-bit mode (thanks to spacechase0!).
* Reducing load time when scanning/rewriting many mods for compatibility.
* For console commands:
* Added `hurry_all` command which immediately warps all NPCs to their scheduled positions.

15
src/SMAPI/Framework/ModLoading/AssemblyLoader.cs
View File

@ -300,10 +300,10 @@ namespace StardewModdingAPI.Framework.ModLoading
// remove old assembly reference
if (this.AssemblyMap.RemoveNames.Any(name => module.AssemblyReferences[i].Name == name))
{
this.Monitor.LogOnce(loggedMessages, $"{logPrefix}Rewriting {filename} for OS...");
platformChanged = true;
module.AssemblyReferences.RemoveAt(i);
i--;
this.Monitor.LogOnce(loggedMessages, $"{logPrefix}Rewrote {filename} for OS...");
}
}
if (platformChanged)
@ -394,7 +394,7 @@ namespace StardewModdingAPI.Framework.ModLoading
break;
case InstructionHandleResult.DetectedGamePatch:
template = $"{logPrefix}Detected game patcher ($phrase) in assembly {filename}.";
template = $"{logPrefix}Detected game patcher in assembly {filename}."; // no need for phrase, which would confusingly be 'Harmony 1.x' here
mod.SetWarning(ModWarning.PatchesGame);
break;
@ -438,13 +438,10 @@ namespace StardewModdingAPI.Framework.ModLoading
return;
// format messages
if (handler.Phrases.Any())
{
foreach (string message in handler.Phrases)
this.Monitor.LogOnce(loggedMessages, template.Replace("$phrase", message));
}
else
this.Monitor.LogOnce(loggedMessages, template.Replace("$phrase", handler.DefaultPhrase ?? handler.GetType().Name));
string phrase = handler.Phrases.Any()
? string.Join(", ", handler.Phrases)
: handler.DefaultPhrase ?? handler.GetType().Name;
this.Monitor.LogOnce(loggedMessages, template.Replace("$phrase", phrase));
}
/// <summary>Get the correct reference to use for compatibility with the current platform.</summary>

59
src/SMAPI/Framework/ModLoading/Finders/EventFinder.cs
View File

@ -1,3 +1,5 @@
using System.Collections.Generic;
using System.Linq;
using Mono.Cecil;
using Mono.Cecil.Cil;
using StardewModdingAPI.Framework.ModLoading.Framework;
@ -13,8 +15,8 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
/// <summary>The full type name for which to find references.</summary>
private readonly string FullTypeName;
/// <summary>The event name for which to find references.</summary>
private readonly string EventName;
/// <summary>The method names for which to find references.</summary>
private readonly ISet<string> MethodNames;
/// <summary>The result to return for matching instructions.</summary>
private readonly InstructionHandleResult Result;
@ -23,40 +25,49 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="fullTypeName">The full type name for which to find references.</param>
/// <param name="eventNames">The event names for which to find references.</param>
/// <param name="result">The result to return for matching instructions.</param>
public EventFinder(string fullTypeName, string[] eventNames, InstructionHandleResult result)
: base(defaultPhrase: $"{string.Join(", ", eventNames.Select(p => $"{fullTypeName}.{p}"))} event{(eventNames.Length != 1 ? "s" : "")}") // default phrase should never be used
{
this.FullTypeName = fullTypeName;
this.Result = result;
this.MethodNames = new HashSet<string>();
foreach (string name in eventNames)
{
this.MethodNames.Add($"add_{name}");
this.MethodNames.Add($"remove_{name}");
}
}
/// <summary>Construct an instance.</summary>
/// <param name="fullTypeName">The full type name for which to find references.</param>
/// <param name="eventName">The event name for which to find references.</param>
/// <param name="result">The result to return for matching instructions.</param>
public EventFinder(string fullTypeName, string eventName, InstructionHandleResult result)
: base(defaultPhrase: $"{fullTypeName}.{eventName} event")
{
this.FullTypeName = fullTypeName;
this.EventName = eventName;
this.Result = result;
}
: this(fullTypeName, new[] { eventName }, result) { }
/// <inheritdoc />
public override bool Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction)
{
if (!this.Flags.Contains(this.Result) && this.IsMatch(instruction))
if (this.MethodNames.Any())
{
MethodReference methodRef = RewriteHelper.AsMethodReference(instruction);
if (methodRef is not null && methodRef.DeclaringType.FullName == this.FullTypeName && this.MethodNames.Contains(methodRef.Name))
{
string eventName = methodRef.Name.Split(new[] { '_' }, 2)[1];
this.MethodNames.Remove($"add_{eventName}");
this.MethodNames.Remove($"remove_{eventName}");
this.MarkFlag(this.Result);
this.Phrases.Add($"{this.FullTypeName}.{eventName} event");
}
}
return false;
}
/*********
** Protected methods
*********/
/// <summary>Get whether a CIL instruction matches.</summary>
/// <param name="instruction">The IL instruction.</param>
protected bool IsMatch(Instruction instruction)
{
MethodReference methodRef = RewriteHelper.AsMethodReference(instruction);
return
methodRef != null
&& methodRef.DeclaringType.FullName == this.FullTypeName
&& (methodRef.Name == "add_" + this.EventName || methodRef.Name == "remove_" + this.EventName);
}
}
}

36
src/SMAPI/Framework/ModLoading/Finders/FieldFinder.cs
View File

@ -1,3 +1,5 @@
using System.Collections.Generic;
using System.Linq;
using Mono.Cecil;
using Mono.Cecil.Cil;
using StardewModdingAPI.Framework.ModLoading.Framework;
@ -13,8 +15,8 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
/// <summary>The full type name for which to find references.</summary>
private readonly string FullTypeName;
/// <summary>The field name for which to find references.</summary>
private readonly string FieldName;
/// <summary>The field names for which to find references.</summary>
private readonly ISet<string> FieldNames;
/// <summary>The result to return for matching instructions.</summary>
private readonly InstructionHandleResult Result;
@ -23,23 +25,39 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="fullTypeName">The full type name for which to find references.</param>
/// <param name="fieldNames">The field names for which to find references.</param>
/// <param name="result">The result to return for matching instructions.</param>
public FieldFinder(string fullTypeName, string[] fieldNames, InstructionHandleResult result)
: base(defaultPhrase: $"{string.Join(", ", fieldNames.Select(p => $"{fullTypeName}.{p}"))} field{(fieldNames.Length != 1 ? "s" : "")}") // default phrase should never be used
{
this.FullTypeName = fullTypeName;
this.FieldNames = new HashSet<string>(fieldNames);
this.Result = result;
}
/// <summary>Construct an instance.</summary>
/// <param name="fullTypeName">The full type name for which to find references.</param>
/// <param name="fieldName">The field name for which to find references.</param>
/// <param name="result">The result to return for matching instructions.</param>
public FieldFinder(string fullTypeName, string fieldName, InstructionHandleResult result)
: base(defaultPhrase: $"{fullTypeName}.{fieldName} field")
{
this.FullTypeName = fullTypeName;
this.FieldName = fieldName;
this.Result = result;
}
: this(fullTypeName, new[] { fieldName }, result) { }
/// <inheritdoc />
public override bool Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction)
{
if (!this.Flags.Contains(this.Result) && RewriteHelper.IsFieldReferenceTo(instruction, this.FullTypeName, this.FieldName))
if (this.FieldNames.Any())
{
FieldReference fieldRef = RewriteHelper.AsFieldReference(instruction);
if (fieldRef is not null && fieldRef.DeclaringType.FullName == this.FullTypeName && this.FieldNames.Contains(fieldRef.Name))
{
this.FieldNames.Remove(fieldRef.Name);
this.MarkFlag(this.Result);
this.Phrases.Add($"{this.FullTypeName}.{fieldRef.Name} field");
}
}
return false;
}

6
src/SMAPI/Framework/ModLoading/Finders/ReferenceToMemberWithUnexpectedTypeFinder.cs
View File

@ -14,7 +14,7 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
** Fields
*********/
/// <summary>The assembly names to which to heuristically detect broken references.</summary>
private readonly HashSet<string> ValidateReferencesToAssemblies;
private readonly ISet<string> ValidateReferencesToAssemblies;
/*********
@ -22,10 +22,10 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
*********/
/// <summary>Construct an instance.</summary>
/// <param name="validateReferencesToAssemblies">The assembly names to which to heuristically detect broken references.</param>
public ReferenceToMemberWithUnexpectedTypeFinder(string[] validateReferencesToAssemblies)
public ReferenceToMemberWithUnexpectedTypeFinder(ISet<string> validateReferencesToAssemblies)
: base(defaultPhrase: "")
{
this.ValidateReferencesToAssemblies = new HashSet<string>(validateReferencesToAssemblies);
this.ValidateReferencesToAssemblies = validateReferencesToAssemblies;
}
/// <inheritdoc />

6
src/SMAPI/Framework/ModLoading/Finders/ReferenceToMissingMemberFinder.cs
View File

@ -13,7 +13,7 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
** Fields
*********/
/// <summary>The assembly names to which to heuristically detect broken references.</summary>
private readonly HashSet<string> ValidateReferencesToAssemblies;
private readonly ISet<string> ValidateReferencesToAssemblies;
/*********
@ -21,10 +21,10 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
*********/
/// <summary>Construct an instance.</summary>
/// <param name="validateReferencesToAssemblies">The assembly names to which to heuristically detect broken references.</param>
public ReferenceToMissingMemberFinder(string[] validateReferencesToAssemblies)
public ReferenceToMissingMemberFinder(ISet<string> validateReferencesToAssemblies)
: base(defaultPhrase: "")
{
this.ValidateReferencesToAssemblies = new HashSet<string>(validateReferencesToAssemblies);
this.ValidateReferencesToAssemblies = validateReferencesToAssemblies;
}
/// <inheritdoc />

27
src/SMAPI/Framework/ModLoading/Finders/TypeFinder.cs
View File

@ -1,4 +1,5 @@
using System;
using System.Collections.Generic;
using Mono.Cecil;
using StardewModdingAPI.Framework.ModLoading.Framework;
@ -10,8 +11,8 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
/*********
** Fields
*********/
/// <summary>The full type name to match.</summary>
private readonly string FullTypeName;
/// <summary>The full type names remaining to match.</summary>
private readonly ISet<string> FullTypeNames;
/// <summary>The result to return for matching instructions.</summary>
private readonly InstructionHandleResult Result;
@ -24,22 +25,34 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="fullTypeName">The full type name to match.</param>
/// <param name="fullTypeNames">The full type names to match.</param>
/// <param name="result">The result to return for matching instructions.</param>
/// <param name="shouldIgnore">Get whether a matched type should be ignored.</param>
public TypeFinder(string fullTypeName, InstructionHandleResult result, Func<TypeReference, bool> shouldIgnore = null)
: base(defaultPhrase: $"{fullTypeName} type")
public TypeFinder(string[] fullTypeNames, InstructionHandleResult result, Func<TypeReference, bool> shouldIgnore = null)
: base(defaultPhrase: $"{string.Join(", ", fullTypeNames)} type{(fullTypeNames.Length != 1 ? "s" : "")}") // default phrase should never be used
{
this.FullTypeName = fullTypeName;
this.FullTypeNames = new HashSet<string>(fullTypeNames);
this.Result = result;
this.ShouldIgnore = shouldIgnore;
}
/// <summary>Construct an instance.</summary>
/// <param name="fullTypeName">The full type name to match.</param>
/// <param name="result">The result to return for matching instructions.</param>
/// <param name="shouldIgnore">Get whether a matched type should be ignored.</param>
public TypeFinder(string fullTypeName, InstructionHandleResult result, Func<TypeReference, bool> shouldIgnore = null)
: this(new[] { fullTypeName }, result, shouldIgnore) { }
/// <inheritdoc />
public override bool Handle(ModuleDefinition module, TypeReference type, Action<TypeReference> replaceWith)
{
if (type.FullName == this.FullTypeName && this.ShouldIgnore?.Invoke(type) != true)
if (this.FullTypeNames.Contains(type.FullName) && this.ShouldIgnore?.Invoke(type) != true)
{
this.FullTypeNames.Remove(type.FullName);
this.MarkFlag(this.Result);
this.Phrases.Add($"{type.FullName} type");
}
return false;
}

24
src/SMAPI/Framework/ModLoading/Rewriters/Harmony1AssemblyRewriter.cs → src/SMAPI/Framework/ModLoading/Rewriters/HarmonyRewriter.cs
View File

@ -7,8 +7,8 @@ using StardewModdingAPI.Framework.ModLoading.RewriteFacades;
namespace StardewModdingAPI.Framework.ModLoading.Rewriters
{
/// <summary>Rewrites Harmony 1.x assembly references to work with Harmony 2.x.</summary>
internal class Harmony1AssemblyRewriter : BaseInstructionHandler
/// <summary>Detects Harmony references, and rewrites Harmony 1.x assembly references to work with Harmony 2.x.</summary>
internal class HarmonyRewriter : BaseInstructionHandler
{
/*********
** Fields
@ -16,19 +16,29 @@ namespace StardewModdingAPI.Framework.ModLoading.Rewriters
/// <summary>Whether any Harmony 1.x types were replaced.</summary>
private bool ReplacedTypes;
/// <summary>Whether to rewrite Harmony 1.x code.</summary>
private readonly bool ShouldRewrite;
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
public Harmony1AssemblyRewriter()
: base(defaultPhrase: "Harmony 1.x") { }
public HarmonyRewriter(bool shouldRewrite = true)
: base(defaultPhrase: "Harmony 1.x")
{
this.ShouldRewrite = shouldRewrite;
}
/// <inheritdoc />
public override bool Handle(ModuleDefinition module, TypeReference type, Action<TypeReference> replaceWith)
{
// detect Harmony
if (type.Scope is not AssemblyNameReference { Name: "0Harmony" } scope)
return false;
// rewrite Harmony 1.x type to Harmony 2.0 type
if (type.Scope is AssemblyNameReference { Name: "0Harmony" } scope && scope.Version.Major == 1)
if (this.ShouldRewrite && scope.Version.Major == 1)
{
Type targetType = this.GetMappedType(type);
replaceWith(module.ImportReference(targetType));
@ -37,11 +47,14 @@ namespace StardewModdingAPI.Framework.ModLoading.Rewriters
return true;
}
this.MarkFlag(InstructionHandleResult.DetectedGamePatch);
return false;
}
/// <inheritdoc />
public override bool Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction)
{
if (this.ShouldRewrite)
{
// rewrite Harmony 1.x methods to Harmony 2.0
MethodReference methodRef = RewriteHelper.AsMethodReference(instruction);
@ -61,6 +74,7 @@ namespace StardewModdingAPI.Framework.ModLoading.Rewriters
this.OnChanged();
}
}
}
return false;
}

6
src/SMAPI/Framework/ModLoading/Rewriters/HeuristicFieldRewriter.cs
View File

@ -13,7 +13,7 @@ namespace StardewModdingAPI.Framework.ModLoading.Rewriters
** Fields
*********/
/// <summary>The assembly names to which to rewrite broken references.</summary>
private readonly HashSet<string> RewriteReferencesToAssemblies;
private readonly ISet<string> RewriteReferencesToAssemblies;
/*********
@ -21,10 +21,10 @@ namespace StardewModdingAPI.Framework.ModLoading.Rewriters
*********/
/// <summary>Construct an instance.</summary>
/// <param name="rewriteReferencesToAssemblies">The assembly names to which to rewrite broken references.</param>
public HeuristicFieldRewriter(string[] rewriteReferencesToAssemblies)
public HeuristicFieldRewriter(ISet<string> rewriteReferencesToAssemblies)
: base(defaultPhrase: "field changed to property") // ignored since we specify phrases
{
this.RewriteReferencesToAssemblies = new HashSet<string>(rewriteReferencesToAssemblies);
this.RewriteReferencesToAssemblies = rewriteReferencesToAssemblies;
}
/// <inheritdoc />

6
src/SMAPI/Framework/ModLoading/Rewriters/HeuristicMethodRewriter.cs
View File

@ -13,7 +13,7 @@ namespace StardewModdingAPI.Framework.ModLoading.Rewriters
** Fields
*********/
/// <summary>The assembly names to which to rewrite broken references.</summary>
private readonly HashSet<string> RewriteReferencesToAssemblies;
private readonly ISet<string> RewriteReferencesToAssemblies;
/*********
@ -21,10 +21,10 @@ namespace StardewModdingAPI.Framework.ModLoading.Rewriters
*********/
/// <summary>Construct an instance.</summary>
/// <param name="rewriteReferencesToAssemblies">The assembly names to which to rewrite broken references.</param>
public HeuristicMethodRewriter(string[] rewriteReferencesToAssemblies)
public HeuristicMethodRewriter(ISet<string> rewriteReferencesToAssemblies)
: base(defaultPhrase: "methods with missing parameters") // ignored since we specify phrases
{
this.RewriteReferencesToAssemblies = new HashSet<string>(rewriteReferencesToAssemblies);
this.RewriteReferencesToAssemblies = rewriteReferencesToAssemblies;
}
/// <inheritdoc />

36
src/SMAPI/Metadata/InstructionMetadata.cs
View File

@ -18,7 +18,7 @@ namespace StardewModdingAPI.Metadata
*********/
/// <summary>The assembly names to which to heuristically detect broken references.</summary>
/// <remarks>The current implementation only works correctly with assemblies that should always be present.</remarks>
private readonly string[] ValidateReferencesToAssemblies = { "StardewModdingAPI", "Stardew Valley", "StardewValley", "Netcode" };
private readonly ISet<string> ValidateReferencesToAssemblies = new HashSet<string> { "StardewModdingAPI", "Stardew Valley", "StardewValley", "Netcode" };
/*********
@ -48,14 +48,16 @@ namespace StardewModdingAPI.Metadata
yield return new HeuristicFieldRewriter(this.ValidateReferencesToAssemblies);
yield return new HeuristicMethodRewriter(this.ValidateReferencesToAssemblies);
// rewrite for SMAPI 3.12 (Harmony 1.x => 2.0 update)
yield return new Harmony1AssemblyRewriter();
// detect Harmony & rewrite for SMAPI 3.12 (Harmony 1.x => 2.0 update)
yield return new HarmonyRewriter();
// rewrite for 64-bit mode
#if SMAPI_FOR_WINDOWS_64BIT_HACK
yield return new ArchitectureAssemblyRewriter();
#endif
}
else
yield return new HarmonyRewriter(shouldRewrite: false);
/****
** detect mod issues
@ -67,13 +69,9 @@ namespace StardewModdingAPI.Metadata
/****
** detect code which may impact game stability
****/
yield return new TypeFinder(typeof(HarmonyLib.Harmony).FullName, InstructionHandleResult.DetectedGamePatch);
yield return new TypeFinder("System.Runtime.CompilerServices.CallSite", InstructionHandleResult.DetectedDynamic);
yield return new FieldFinder(typeof(SaveGame).FullName, nameof(SaveGame.serializer), InstructionHandleResult.DetectedSaveSerializer);
yield return new FieldFinder(typeof(SaveGame).FullName, nameof(SaveGame.farmerSerializer), InstructionHandleResult.DetectedSaveSerializer);
yield return new FieldFinder(typeof(SaveGame).FullName, nameof(SaveGame.locationSerializer), InstructionHandleResult.DetectedSaveSerializer);
yield return new EventFinder(typeof(ISpecializedEvents).FullName, nameof(ISpecializedEvents.UnvalidatedUpdateTicked), InstructionHandleResult.DetectedUnvalidatedUpdateTick);
yield return new EventFinder(typeof(ISpecializedEvents).FullName, nameof(ISpecializedEvents.UnvalidatedUpdateTicking), InstructionHandleResult.DetectedUnvalidatedUpdateTick);
yield return new FieldFinder(typeof(SaveGame).FullName, new[] { nameof(SaveGame.serializer), nameof(SaveGame.farmerSerializer), nameof(SaveGame.locationSerializer) }, InstructionHandleResult.DetectedSaveSerializer);
yield return new EventFinder(typeof(ISpecializedEvents).FullName, new[] { nameof(ISpecializedEvents.UnvalidatedUpdateTicked), nameof(ISpecializedEvents.UnvalidatedUpdateTicking) }, InstructionHandleResult.DetectedUnvalidatedUpdateTick);
/****
** detect paranoid issues
@ -82,13 +80,19 @@ namespace StardewModdingAPI.Metadata
{
// filesystem access
yield return new TypeFinder(typeof(System.Console).FullName, InstructionHandleResult.DetectedConsoleAccess);
yield return new TypeFinder(typeof(System.IO.File).FullName, InstructionHandleResult.DetectedFilesystemAccess);
yield return new TypeFinder(typeof(System.IO.FileStream).FullName, InstructionHandleResult.DetectedFilesystemAccess);
yield return new TypeFinder(typeof(System.IO.FileInfo).FullName, InstructionHandleResult.DetectedFilesystemAccess);
yield return new TypeFinder(typeof(System.IO.Directory).FullName, InstructionHandleResult.DetectedFilesystemAccess);
yield return new TypeFinder(typeof(System.IO.DirectoryInfo).FullName, InstructionHandleResult.DetectedFilesystemAccess);
yield return new TypeFinder(typeof(System.IO.DriveInfo).FullName, InstructionHandleResult.DetectedFilesystemAccess);
yield return new TypeFinder(typeof(System.IO.FileSystemWatcher).FullName, InstructionHandleResult.DetectedFilesystemAccess);
yield return new TypeFinder(
new[]
{
typeof(System.IO.File).FullName,
typeof(System.IO.FileStream).FullName,
typeof(System.IO.FileInfo).FullName,
typeof(System.IO.Directory).FullName,
typeof(System.IO.DirectoryInfo).FullName,
typeof(System.IO.DriveInfo).FullName,
typeof(System.IO.FileSystemWatcher).FullName
},
InstructionHandleResult.DetectedFilesystemAccess
);
// shell access
yield return new TypeFinder(typeof(System.Diagnostics.Process).FullName, InstructionHandleResult.DetectedShellAccess);