Fix .NET 4.8 compatibility

Author: meck-gd

de4dot.code/deobfuscators/dotNET_Reactor/v4/vm/IPattern.cs

@@ -25,29 +25,32 @@ You should have received a copy of the GNU General Public License
 
 namespace de4dot.code.deobfuscators.dotNET_Reactor.v4.vm;
 
-public interface IPattern {
+// Note: These should be interfaces in newer .NET versions, but they aren't
+// because .NET 4.8 doesn't support default implementations.
+
+public abstract record IPattern {
 	/// <summary>
 	/// Contiguous list of opcodes that should match. Nops are wildcards.
 	/// The pattern does not need to overlap the input completely, i.e., it can be a prefix of the input.
 	/// </summary>
-	IList<OpCode> Pattern { get; }
+	public virtual IList<OpCode> Pattern { get; }
 
 	/// <summary>
 	/// If true, the pattern doesn't need to match from the start.
 	/// </summary>
-	bool MatchAnywhere => false;
+	public virtual bool MatchAnywhere => false;
 
 	/// <summary>
 	/// Does (optional) additional verification on the input if the pattern would not be unique otherwise.
 	/// </summary>
 	/// <param name="instructions">Matched instructions from the input.</param>
 	/// <returns>True if this should indeed be a match.</returns>
-	bool Verify(IList<Instruction> instructions) => true;
+	public virtual bool Verify(IList<Instruction> instructions) => true;
 }
 
-public interface IOpcodePattern : IPattern {
+public abstract record IOpcodePattern : IPattern {
 	/// <summary>
 	/// Resulting opcode assigned to the match.
 	/// </summary>
-	OpCode Opcode { get; }
+	public virtual OpCode Opcode { get; }
 }

de4dot.code/deobfuscators/dotNET_Reactor/v4/vm/PatternHelper.cs

@@ -58,11 +58,11 @@ public static bool FindPatternInOverridesCall(this MethodDef? virtualMethod, IPa
 			var firstOverride = t.Methods.FirstOrDefault(m => m.IsVirtual && m.HasBody
 			                                                              && m.Name == virtualMethod.Name
 			                                                              && m.Body.Instructions.Count >= 3
-			                                                              && m.Body.Instructions[^2].OpCode == OpCodes.Callvirt);
+			                                                              && m.Body.Instructions[m.Body.Instructions.Count - 2].OpCode == OpCodes.Callvirt); // net48 compat
 			if (firstOverride == null)
 				continue;
 
-			var calledInOverride = ((MethodDef)firstOverride.Body.Instructions[^2].Operand).Name;
+			var calledInOverride = ((MethodDef)firstOverride.Body.Instructions[firstOverride.Body.Instructions.Count - 2].Operand).Name; // net48 compat
 			foreach (var t2 in virtualMethod.Module.GetTypes()) {
 				foreach (var callee in t2.Methods.Where(m => m.IsVirtual && m.HasBody && m.Name == calledInOverride)) {
 					if (PatternMatcher.Match(pattern, callee.Body.Instructions))

de4dot.code/deobfuscators/dotNET_Reactor/v4/vm/PatternMatcher.cs

@@ -39,12 +39,12 @@ public PatternMatcher()
 		_opcodes = new Dictionary<int, IOpcodePattern>();
 		_opcodePatterns = new List<IOpcodePattern>();
 		foreach (var type in typeof(PatternMatcher).Assembly.GetTypes())
-			if (type.GetInterface(nameof(IOpcodePattern)) != null)
+			if (!type.IsAbstract && typeof(IOpcodePattern).IsAssignableFrom(type))
 				if (Activator.CreateInstance(type) is IOpcodePattern instance)
 					_opcodePatterns.Add(instance);
 	}
 
-	public IOpcodePattern? GetOpcode(int vmOpcode) => _opcodes.GetValueOrDefault(vmOpcode);
+	public IOpcodePattern? GetOpcode(int vmOpcode) => _opcodes.TryGetValue(vmOpcode, out var res) ? res : null; // net48 compat
 
 	public void MatchAll(HandlerMapper mapper) {
 		int numMatched = 0;