internal MethodPatcher(MethodBase original, MethodBase source, string harmonyInstanceID, List <MethodInfo> prefixes, List <MethodInfo> postfixes, List <MethodInfo> transpilers, List <MethodInfo> finalizers)
{
if (original == null)
{
throw new ArgumentNullException(nameof(original));
}
this.original = original;
this.source = source;
this.harmonyInstanceID = harmonyInstanceID;
this.prefixes = prefixes;
this.postfixes = postfixes;
this.transpilers = transpilers;
this.finalizers = finalizers;
Memory.MarkForNoInlining(original);
if (Harmony.DEBUG)
{
FileLog.LogBuffered($"### Patch {original.FullDescription()}");
FileLog.FlushBuffer();
}
idx = prefixes.Count() + postfixes.Count() + finalizers.Count();
firstArgIsReturnBuffer = NativeThisPointer.NeedsNativeThisPointerFix(original);
returnType = AccessTools.GetReturnedType(original);
patch = CreateDynamicMethod(original, $"_Patch{idx}");
if (patch == null)
{
throw new Exception("Could not create dynamic method");
}
il = patch.GetILGenerator();
emitter = new Emitter(il);
}
/// <summary>A a full description of a method or a constructor without assembly details but with generics</summary>
/// <param name="member">The method/constructor</param>
/// <returns>A human readable description</returns>
///
public static string FullDescription(this MethodBase member)
{
if (member is null)
{
return("null");
}
var returnType = AccessTools.GetReturnedType(member);
var result = new StringBuilder();
if (member.IsStatic)
{
_ = result.Append("static ");
}
if (member.IsAbstract)
{
_ = result.Append("abstract ");
}
if (member.IsVirtual)
{
_ = result.Append("virtual ");
}
_ = result.Append($"{returnType.FullDescription()} ");
if (member.DeclaringType is object)
{
_ = result.Append($"{member.DeclaringType.FullDescription()}::");
}
var parameterString = member.GetParameters().Join(p => $"{p.ParameterType.FullDescription()} {p.Name}");
_ = result.Append($"{member.Name}({parameterString})");
return(result.ToString());
}
/// <summary>A a full description of a method or a constructor without assembly details but with generics</summary>
/// <param name="member">The method/constructor</param>
/// <returns>A human readable description</returns>
///
public static string FullDescription(this MethodBase member)
{
if (member == null)
{
return("null");
}
var parameters = member.GetParameters().Types();
var returnType = AccessTools.GetReturnedType(member);
var strings = new List <string>();
if (member.IsStatic)
{
strings.Add("static");
}
if (member.IsAbstract)
{
strings.Add("abstract");
}
if (member.IsVirtual)
{
strings.Add("virtual");
}
strings.Add(returnType.FullDescription());
if (member.DeclaringType != null)
{
strings.Add(member.DeclaringType.FullDescription());
}
strings.Add($"{member.Name}{parameters.Description()}");
return(strings.ToArray().Join(null, " "));
}
internal static bool NeedsFix(MethodBase method)
{
var returnType = AccessTools.GetReturnedType(method);
if (AccessTools.IsStruct(returnType) is false)
{
return(false);
}
if (AccessTools.IsMonoRuntime is false && method.IsStatic)
{
return(false);
}
if (AccessTools.IsMonoRuntime && method.IsStatic is false)
{
return(false);
}
var size = SizeOf(returnType);
if (specialSizes.Contains(size))
{
return(false);
}
return(HasStructReturnBuffer());
}
/// <summary>A a full description of a method or a constructor without assembly details but with generics</summary>
/// <param name="method">The method or constructor</param>
/// <returns>A human readable description</returns>
///
public static string FullDescription(this MethodBase method)
{
if (method == null)
{
return("null");
}
var parameters = method.GetParameters().Select(p => p.ParameterType).ToArray();
var returnType = AccessTools.GetReturnedType(method);
return(returnType.FullDescription() + " " + method.DeclaringType.FullDescription() + "." + method.Name + parameters.Description());
}
internal static DynamicMethodDefinition CreateDynamicMethod(MethodBase original, string suffix)
{
if (original == null)
{
throw new ArgumentNullException(nameof(original));
}
var patchName = original.Name + suffix;
patchName = patchName.Replace("<>", "");
var parameters = original.GetParameters();
var parameterTypes = parameters.Types().ToList();
if (original.IsStatic == false)
{
if (AccessTools.IsStruct(original.DeclaringType))
{
parameterTypes.Insert(0, original.DeclaringType.MakeByRefType());
}
else
{
parameterTypes.Insert(0, original.DeclaringType);
}
}
var firstArgIsReturnBuffer = NativeThisPointer.NeedsNativeThisPointerFix(original);
if (firstArgIsReturnBuffer)
{
parameterTypes.Insert(0, typeof(IntPtr));
}
var returnType = firstArgIsReturnBuffer ? typeof(void) : AccessTools.GetReturnedType(original);
var method = new DynamicMethodDefinition(
patchName,
returnType,
parameterTypes.ToArray()
);
#if NETSTANDARD2_0 || NETCOREAPP2_0
#else
var offset = (original.IsStatic ? 0 : 1) + (firstArgIsReturnBuffer ? 1 : 0);
for (var i = 0; i < parameters.Length; i++)
{
var param = method.Definition.Parameters[i + offset];
param.Attributes = (Mono.Cecil.ParameterAttributes)parameters[i].Attributes;
param.Name = parameters[i].Name;
}
#endif
return(method);
}
/// <summary>A a full description of a method or a constructor without assembly details but with generics</summary>
/// <param name="member">The method/constructor</param>
/// <returns>A human readable description</returns>
///
public static string FullDescription(this MethodBase member)
{
if (member == null)
{
return("null");
}
var parameters = member.GetParameters().Types();
var returnType = AccessTools.GetReturnedType(member);
if (member.DeclaringType == null)
{
return($"{returnType.FullDescription()} {member.Name}{parameters.Description()}");
}
return($"{returnType.FullDescription()} {member.DeclaringType.FullDescription()}.{member.Name}{parameters.Description()}");
}
internal static bool NeedsNativeThisPointerFix(MethodBase method)
{
if (method.IsStatic)
{
return(false);
}
var returnType = AccessTools.GetReturnedType(method);
if (AccessTools.IsStruct(returnType) == false)
{
return(false);
}
var size = Marshal.SizeOf(returnType);
if (size != 3 && size != 5 && size != 6 && size != 7 && size < 9)
{
return(false);
}
return(HasNativeThis());
}
internal static bool NeedsFix(MethodBase method)
{
if (method.IsStatic)
{
return(false);
}
var returnType = AccessTools.GetReturnedType(method);
if (AccessTools.IsStruct(returnType) == false)
{
return(false);
}
var size = SizeOf(returnType);
if (size != 3 && size != 5 && size != 6 && size != 7 && size < 9)
{
return(false);
}
return(HasStructReturnBuffer());
}
internal MethodPatcher(MethodBase original, MethodBase source, List <MethodInfo> prefixes, List <MethodInfo> postfixes, List <MethodInfo> transpilers, List <MethodInfo> finalizers, bool debug)
{
if (original is null)
{
throw new ArgumentNullException(nameof(original));
}
this.debug = debug;
this.original = original;
this.source = source;
this.prefixes = prefixes;
this.postfixes = postfixes;
this.transpilers = transpilers;
this.finalizers = finalizers;
Memory.MarkForNoInlining(original);
if (debug)
{
FileLog.LogBuffered($"### Patch: {original.FullDescription()}");
FileLog.FlushBuffer();
}
idx = prefixes.Count() + postfixes.Count() + finalizers.Count();
useStructReturnBuffer = StructReturnBuffer.NeedsFix(original);
if (debug && useStructReturnBuffer)
{
FileLog.Log($"### Note: A buffer for the returned struct is used. That requires an extra IntPtr argument before the first real argument");
}
returnType = AccessTools.GetReturnedType(original);
patch = CreateDynamicMethod(original, $"_Patch{idx}", debug);
if (patch is null)
{
throw new Exception("Could not create replacement method");
}
il = patch.GetILGenerator();
emitter = new Emitter(il, debug);
}
internal MethodPatcher(MethodBase original, MethodBase source, List <MethodInfo> prefixes, List <MethodInfo> postfixes, List <MethodInfo> transpilers, List <MethodInfo> finalizers, bool debug)
{
if (original == null)
{
throw new ArgumentNullException(nameof(original));
}
this.debug = debug;
this.original = original;
this.source = source;
this.prefixes = prefixes;
this.postfixes = postfixes;
this.transpilers = transpilers;
this.finalizers = finalizers;
Memory.MarkForNoInlining(original);
if (debug)
{
FileLog.LogBuffered($"### Patch {original.FullDescription()}");
FileLog.FlushBuffer();
}
idx = prefixes.Count() + postfixes.Count() + finalizers.Count();
firstArgIsReturnBuffer = NativeThisPointer.NeedsNativeThisPointerFix(original);
if (debug && firstArgIsReturnBuffer)
{
FileLog.Log($"### Special case: extra argument after 'this' is pointer to valuetype (simulate return value)");
}
returnType = AccessTools.GetReturnedType(original);
patch = CreateDynamicMethod(original, $"_Patch{idx}", debug);
if (patch == null)
{
throw new Exception("Could not create replacement method");
}
il = patch.GetILGenerator();
emitter = new Emitter(il, debug);
}
void EmitCallParameter(MethodInfo patch, Dictionary <string, LocalBuilder> variables, bool allowFirsParamPassthrough, out LocalBuilder tmpObjectVar)
{
tmpObjectVar = null;
var isInstance = original.IsStatic is false;
var originalParameters = original.GetParameters();
var originalParameterNames = originalParameters.Select(p => p.Name).ToArray();
// check for passthrough using first parameter (which must have same type as return type)
var parameters = patch.GetParameters().ToList();
if (allowFirsParamPassthrough && patch.ReturnType != typeof(void) && parameters.Count > 0 && parameters[0].ParameterType == patch.ReturnType)
{
parameters.RemoveRange(0, 1);
}
foreach (var patchParam in parameters)
{
if (patchParam.Name == ORIGINAL_METHOD_PARAM)
{
if (EmitOriginalBaseMethod())
{
continue;
}
emitter.Emit(OpCodes.Ldnull);
continue;
}
if (patchParam.Name == INSTANCE_PARAM)
{
if (original.IsStatic)
{
emitter.Emit(OpCodes.Ldnull);
}
else
{
var instanceIsRef = original.DeclaringType is object && AccessTools.IsStruct(original.DeclaringType);
var parameterIsRef = patchParam.ParameterType.IsByRef;
if (instanceIsRef == parameterIsRef)
{
emitter.Emit(OpCodes.Ldarg_0);
}
if (instanceIsRef && parameterIsRef is false)
{
emitter.Emit(OpCodes.Ldarg_0);
emitter.Emit(OpCodes.Ldobj, original.DeclaringType);
}
if (instanceIsRef is false && parameterIsRef)
{
emitter.Emit(OpCodes.Ldarga, 0);
}
}
continue;
}
if (patchParam.Name.StartsWith(INSTANCE_FIELD_PREFIX, StringComparison.Ordinal))
{
var fieldName = patchParam.Name.Substring(INSTANCE_FIELD_PREFIX.Length);
FieldInfo fieldInfo;
if (fieldName.All(char.IsDigit))
{
// field access by index only works for declared fields
fieldInfo = AccessTools.DeclaredField(original.DeclaringType, int.Parse(fieldName));
if (fieldInfo is null)
{
throw new ArgumentException($"No field found at given index in class {original.DeclaringType.FullName}", fieldName);
}
}
else
{
fieldInfo = AccessTools.Field(original.DeclaringType, fieldName);
if (fieldInfo is null)
{
throw new ArgumentException($"No such field defined in class {original.DeclaringType.FullName}", fieldName);
}
}
if (fieldInfo.IsStatic)
{
emitter.Emit(patchParam.ParameterType.IsByRef ? OpCodes.Ldsflda : OpCodes.Ldsfld, fieldInfo);
}
else
{
emitter.Emit(OpCodes.Ldarg_0);
emitter.Emit(patchParam.ParameterType.IsByRef ? OpCodes.Ldflda : OpCodes.Ldfld, fieldInfo);
}
continue;
}
// state is special too since each patch has its own local var
if (patchParam.Name == STATE_VAR)
{
var ldlocCode = patchParam.ParameterType.IsByRef ? OpCodes.Ldloca : OpCodes.Ldloc;
if (variables.TryGetValue(patch.DeclaringType.FullName, out var stateVar))
{
emitter.Emit(ldlocCode, stateVar);
}
else
{
emitter.Emit(OpCodes.Ldnull);
}
continue;
}
// treat __result var special
if (patchParam.Name == RESULT_VAR)
{
var returnType = AccessTools.GetReturnedType(original);
if (returnType == typeof(void))
{
throw new Exception($"Cannot get result from void method {original.FullDescription()}");
}
var resultType = patchParam.ParameterType;
if (resultType.IsByRef && returnType.IsByRef == false)
{
resultType = resultType.GetElementType();
}
if (resultType.IsAssignableFrom(returnType) is false)
{
throw new Exception($"Cannot assign method return type {returnType.FullName} to {RESULT_VAR} type {resultType.FullName} for method {original.FullDescription()}");
}
var ldlocCode = patchParam.ParameterType.IsByRef && returnType.IsByRef == false ? OpCodes.Ldloca : OpCodes.Ldloc;
if (returnType.IsValueType && patchParam.ParameterType == typeof(object).MakeByRefType())
{
ldlocCode = OpCodes.Ldloc;
}
emitter.Emit(ldlocCode, variables[RESULT_VAR]);
if (returnType.IsValueType)
{
if (patchParam.ParameterType == typeof(object))
{
emitter.Emit(OpCodes.Box, returnType);
}
else if (patchParam.ParameterType == typeof(object).MakeByRefType())
{
emitter.Emit(OpCodes.Box, returnType);
tmpObjectVar = il.DeclareLocal(typeof(object));
emitter.Emit(OpCodes.Stloc, tmpObjectVar);
emitter.Emit(OpCodes.Ldloca, tmpObjectVar);
}
}
continue;
}
// handle __args var special
if (patchParam.Name == ARGS_VAR)
{
if (originalParameters.Length == 0)
{
emitter.Emit(OpCodes.Ldnull);
continue;
}
int shift = (isInstance ? 1 : 0) + (useStructReturnBuffer ? 1 : 0);
emitter.Emit(OpCodes.Ldc_I4, originalParameters.Length);
emitter.Emit(OpCodes.Newarr, typeof(object));
for (int i = 0; i < originalParameters.Length; i++)
{
emitter.Emit(OpCodes.Dup);
emitter.Emit(OpCodes.Ldc_I4, i);
emitter.Emit(OpCodes.Ldarg, i + shift);
if (originalParameters[i].ParameterType.IsValueType)
{
emitter.Emit(OpCodes.Box, originalParameters[i].ParameterType);
}
emitter.Emit(OpCodes.Stelem_Ref);
}
continue;
}
// any other declared variables
if (variables.TryGetValue(patchParam.Name, out var localBuilder))
{
var ldlocCode = patchParam.ParameterType.IsByRef ? OpCodes.Ldloca : OpCodes.Ldloc;
emitter.Emit(ldlocCode, localBuilder);
continue;
}
int idx;
if (patchParam.Name.StartsWith(PARAM_INDEX_PREFIX, StringComparison.Ordinal))
{
var val = patchParam.Name.Substring(PARAM_INDEX_PREFIX.Length);
if (!int.TryParse(val, out idx))
{
throw new Exception($"Parameter {patchParam.Name} does not contain a valid index");
}
if (idx < 0 || idx >= originalParameters.Length)
{
throw new Exception($"No parameter found at index {idx}");
}
}
else
{
idx = patch.GetArgumentIndex(originalParameterNames, patchParam);
if (idx == -1)
{
var harmonyMethod = HarmonyMethodExtensions.GetMergedFromType(patchParam.ParameterType);
if (harmonyMethod.methodType is null) // MethodType default is Normal
{
harmonyMethod.methodType = MethodType.Normal;
}
var delegateOriginal = harmonyMethod.GetOriginalMethod();
if (delegateOriginal is MethodInfo methodInfo)
{
var delegateConstructor = patchParam.ParameterType.GetConstructor(new[] { typeof(object), typeof(IntPtr) });
if (delegateConstructor is object)
{
var originalType = original.DeclaringType;
if (methodInfo.IsStatic)
{
emitter.Emit(OpCodes.Ldnull);
}
else
{
emitter.Emit(OpCodes.Ldarg_0);
if (originalType.IsValueType)
{
emitter.Emit(OpCodes.Ldobj, originalType);
emitter.Emit(OpCodes.Box, originalType);
}
}
if (methodInfo.IsStatic is false && harmonyMethod.nonVirtualDelegate is false)
{
emitter.Emit(OpCodes.Dup);
emitter.Emit(OpCodes.Ldvirtftn, methodInfo);
}
else
{
emitter.Emit(OpCodes.Ldftn, methodInfo);
}
emitter.Emit(OpCodes.Newobj, delegateConstructor);
continue;
}
}
throw new Exception($"Parameter \"{patchParam.Name}\" not found in method {original.FullDescription()}");
}
}
// original -> patch opcode
// --------------------------------------
// 1 normal -> normal : LDARG
// 2 normal -> ref/out : LDARGA
// 3 ref/out -> normal : LDARG, LDIND_x
// 4 ref/out -> ref/out : LDARG
//
var originalIsNormal = originalParameters[idx].IsOut is false && originalParameters[idx].ParameterType.IsByRef is false;
var patchIsNormal = patchParam.IsOut is false && patchParam.ParameterType.IsByRef is false;
var patchArgIndex = idx + (isInstance ? 1 : 0) + (useStructReturnBuffer ? 1 : 0);
// Case 1 + 4
if (originalIsNormal == patchIsNormal)
{
emitter.Emit(OpCodes.Ldarg, patchArgIndex);
continue;
}
// Case 2
if (originalIsNormal && patchIsNormal is false)
{
emitter.Emit(OpCodes.Ldarga, patchArgIndex);
continue;
}
// Case 3
emitter.Emit(OpCodes.Ldarg, patchArgIndex);
emitter.Emit(LoadIndOpCodeFor(originalParameters[idx].ParameterType));
}
internal static DynamicMethodDefinition CreateDynamicMethod(MethodBase original, string suffix, bool debug)
{
if (original is null)
{
throw new ArgumentNullException(nameof(original));
}
var useStructReturnBuffer = StructReturnBuffer.NeedsFix(original);
var patchName = $"{original.DeclaringType?.FullName}.{original.Name}{suffix}";
patchName = patchName.Replace("<>", "");
var parameters = original.GetParameters();
var parameterTypes = new List <Type>();
parameterTypes.AddRange(parameters.Types());
if (useStructReturnBuffer)
{
parameterTypes.Insert(0, typeof(IntPtr));
}
if (original.IsStatic is false)
{
if (AccessTools.IsStruct(original.DeclaringType))
{
parameterTypes.Insert(0, original.DeclaringType.MakeByRefType());
}
else
{
parameterTypes.Insert(0, original.DeclaringType);
}
}
var returnType = useStructReturnBuffer ? typeof(void) : AccessTools.GetReturnedType(original);
var method = new DynamicMethodDefinition(
patchName,
returnType,
parameterTypes.ToArray()
)
{
OwnerType = original.DeclaringType
};
var offset = (original.IsStatic ? 0 : 1) + (useStructReturnBuffer ? 1 : 0);
if (useStructReturnBuffer)
{
method.Definition.Parameters[original.IsStatic ? 0 : 1].Name = "retbuf";
}
if (!original.IsStatic)
{
method.Definition.Parameters[0].Name = "this";
}
for (var i = 0; i < parameters.Length; i++)
{
var param = method.Definition.Parameters[i + offset];
param.Attributes = (Mono.Cecil.ParameterAttributes)parameters[i].Attributes;
param.Name = parameters[i].Name;
}
if (debug)
{
var parameterStrings = parameterTypes.Select(p => p.FullDescription()).ToList();
if (parameterTypes.Count == method.Definition.Parameters.Count)
{
for (var i = 0; i < parameterTypes.Count; i++)
{
parameterStrings[i] += $" {method.Definition.Parameters[i].Name}";
}
}
FileLog.Log($"### Replacement: static {returnType.FullDescription()} {original.DeclaringType.FullName}::{patchName}({parameterStrings.Join()})");
}
return(method);
}
public static DynamicMethod CreatePatchedMethod(MethodBase original, MethodBase source, string harmonyInstanceID, List <MethodInfo> prefixes, List <MethodInfo> postfixes, List <MethodInfo> transpilers, List <MethodInfo> finalizers)
{
try
{
if (original == null)
{
throw new ArgumentNullException(nameof(original));
}
Memory.MarkForNoInlining(original);
if (Harmony.DEBUG)
{
FileLog.LogBuffered("### Patch " + original.FullDescription());
FileLog.FlushBuffer();
}
var idx = prefixes.Count() + postfixes.Count() + finalizers.Count();
var firstArgIsReturnBuffer = NativeThisPointer.NeedsNativeThisPointerFix(original);
var returnType = AccessTools.GetReturnedType(original);
var hasFinalizers = finalizers.Any();
var patch = DynamicTools.CreateDynamicMethod(original, "_Patch" + idx);
if (patch == null)
{
return(null);
}
var il = patch.GetILGenerator();
var originalVariables = DynamicTools.DeclareLocalVariables(source ?? original, il);
var privateVars = new Dictionary <string, LocalBuilder>();
LocalBuilder resultVariable = null;
if (idx > 0)
{
resultVariable = DynamicTools.DeclareLocalVariable(il, returnType);
privateVars[RESULT_VAR] = resultVariable;
}
prefixes.Union(postfixes).Union(finalizers).ToList().ForEach(fix =>
{
if (privateVars.ContainsKey(fix.DeclaringType?.FullName ?? "") == false)
{
fix.GetParameters()
.Where(patchParam => patchParam.Name == STATE_VAR)
.Do(patchParam =>
{
var privateStateVariable = DynamicTools.DeclareLocalVariable(il, patchParam.ParameterType);
privateVars[fix.DeclaringType?.FullName ?? ""] = privateStateVariable;
});
}
});
LocalBuilder finalizedVariable = null;
if (hasFinalizers)
{
finalizedVariable = DynamicTools.DeclareLocalVariable(il, typeof(bool));
privateVars[EXCEPTION_VAR] = DynamicTools.DeclareLocalVariable(il, typeof(Exception));
// begin try
Emitter.MarkBlockBefore(il, new ExceptionBlock(ExceptionBlockType.BeginExceptionBlock), out _);
}
if (firstArgIsReturnBuffer)
{
Emitter.Emit(il, OpCodes.Ldarg_1); // load ref to return value
}
var skipOriginalLabel = il.DefineLabel();
var canHaveJump = AddPrefixes(il, original, prefixes, privateVars, skipOriginalLabel);
var copier = new MethodCopier(source ?? original, il, originalVariables);
foreach (var transpiler in transpilers)
{
copier.AddTranspiler(transpiler);
}
if (firstArgIsReturnBuffer)
{
copier.AddTranspiler(NativeThisPointer.m_ArgumentShiftTranspiler);
}
var endLabels = new List <Label>();
copier.Finalize(endLabels);
foreach (var label in endLabels)
{
Emitter.MarkLabel(il, label);
}
if (resultVariable != null)
{
Emitter.Emit(il, OpCodes.Stloc, resultVariable);
}
if (canHaveJump)
{
Emitter.MarkLabel(il, skipOriginalLabel);
}
AddPostfixes(il, original, postfixes, privateVars, false);
if (resultVariable != null)
{
Emitter.Emit(il, OpCodes.Ldloc, resultVariable);
}
AddPostfixes(il, original, postfixes, privateVars, true);
if (hasFinalizers)
{
AddFinalizers(il, original, finalizers, privateVars, false);
Emitter.Emit(il, OpCodes.Ldc_I4_1);
Emitter.Emit(il, OpCodes.Stloc, finalizedVariable);
var noExceptionLabel1 = il.DefineLabel();
Emitter.Emit(il, OpCodes.Ldloc, privateVars[EXCEPTION_VAR]);
Emitter.Emit(il, OpCodes.Brfalse, noExceptionLabel1);
Emitter.Emit(il, OpCodes.Ldloc, privateVars[EXCEPTION_VAR]);
Emitter.Emit(il, OpCodes.Throw);
Emitter.MarkLabel(il, noExceptionLabel1);
// end try, begin catch
Emitter.MarkBlockBefore(il, new ExceptionBlock(ExceptionBlockType.BeginCatchBlock), out var label);
Emitter.Emit(il, OpCodes.Stloc, privateVars[EXCEPTION_VAR]);
Emitter.Emit(il, OpCodes.Ldloc, finalizedVariable);
var endFinalizerLabel = il.DefineLabel();
Emitter.Emit(il, OpCodes.Brtrue, endFinalizerLabel);
var rethrowPossible = AddFinalizers(il, original, finalizers, privateVars, true);
Emitter.MarkLabel(il, endFinalizerLabel);
var noExceptionLabel2 = il.DefineLabel();
Emitter.Emit(il, OpCodes.Ldloc, privateVars[EXCEPTION_VAR]);
Emitter.Emit(il, OpCodes.Brfalse, noExceptionLabel2);
if (rethrowPossible)
{
Emitter.Emit(il, OpCodes.Rethrow);
}
else
{
Emitter.Emit(il, OpCodes.Ldloc, privateVars[EXCEPTION_VAR]);
Emitter.Emit(il, OpCodes.Throw);
}
Emitter.MarkLabel(il, noExceptionLabel2);
// end catch
Emitter.MarkBlockAfter(il, new ExceptionBlock(ExceptionBlockType.EndExceptionBlock));
if (resultVariable != null)
{
Emitter.Emit(il, OpCodes.Ldloc, resultVariable);
}
}
if (firstArgIsReturnBuffer)
{
Emitter.Emit(il, OpCodes.Stobj, returnType); // store result into ref
}
Emitter.Emit(il, OpCodes.Ret);
if (Harmony.DEBUG)
{
FileLog.LogBuffered("DONE");
FileLog.LogBuffered("");
FileLog.FlushBuffer();
}
DynamicTools.PrepareDynamicMethod(patch);
return(patch);
}
catch (Exception ex)
{
var exceptionString = "Exception from HarmonyInstance \"" + harmonyInstanceID + "\" patching " + original.FullDescription() + ": " + ex;
if (Harmony.DEBUG)
{
var savedIndentLevel = FileLog.indentLevel;
FileLog.indentLevel = 0;
FileLog.Log(exceptionString);
FileLog.indentLevel = savedIndentLevel;
}
throw new Exception(exceptionString, ex);
}
finally
{
if (Harmony.DEBUG)
{
FileLog.FlushBuffer();
}
}
}
void EmitCallParameter(MethodInfo patch, Dictionary <string, LocalBuilder> variables, bool allowFirsParamPassthrough)
{
var isInstance = original.IsStatic == false;
var originalParameters = original.GetParameters();
var originalParameterNames = originalParameters.Select(p => p.Name).ToArray();
// check for passthrough using first parameter (which must have same type as return type)
var parameters = patch.GetParameters().ToList();
if (allowFirsParamPassthrough && patch.ReturnType != typeof(void) && parameters.Count > 0 && parameters[0].ParameterType == patch.ReturnType)
{
parameters.RemoveRange(0, 1);
}
foreach (var patchParam in parameters)
{
if (patchParam.Name == ORIGINAL_METHOD_PARAM)
{
if (EmitOriginalBaseMethod())
{
continue;
}
emitter.Emit(OpCodes.Ldnull);
continue;
}
if (patchParam.Name == INSTANCE_PARAM)
{
if (original.IsStatic)
{
emitter.Emit(OpCodes.Ldnull);
}
else
{
var instanceIsRef = original.DeclaringType != null && AccessTools.IsStruct(original.DeclaringType);
var parameterIsRef = patchParam.ParameterType.IsByRef;
if (instanceIsRef == parameterIsRef)
{
emitter.Emit(OpCodes.Ldarg_0);
}
if (instanceIsRef && parameterIsRef == false)
{
emitter.Emit(OpCodes.Ldarg_0);
emitter.Emit(OpCodes.Ldobj, original.DeclaringType);
}
if (instanceIsRef == false && parameterIsRef)
{
emitter.Emit(OpCodes.Ldarga, 0);
}
}
continue;
}
if (patchParam.Name.StartsWith(INSTANCE_FIELD_PREFIX, StringComparison.Ordinal))
{
var fieldName = patchParam.Name.Substring(INSTANCE_FIELD_PREFIX.Length);
FieldInfo fieldInfo;
if (fieldName.All(char.IsDigit))
{
// field access by index only works for declared fields
fieldInfo = AccessTools.DeclaredField(original.DeclaringType, int.Parse(fieldName));
if (fieldInfo == null)
{
throw new ArgumentException($"No field found at given index in class {original.DeclaringType.FullName}", fieldName);
}
}
else
{
fieldInfo = AccessTools.Field(original.DeclaringType, fieldName);
if (fieldInfo == null)
{
throw new ArgumentException($"No such field defined in class {original.DeclaringType.FullName}", fieldName);
}
}
if (fieldInfo.IsStatic)
{
emitter.Emit(patchParam.ParameterType.IsByRef ? OpCodes.Ldsflda : OpCodes.Ldsfld, fieldInfo);
}
else
{
emitter.Emit(OpCodes.Ldarg_0);
emitter.Emit(patchParam.ParameterType.IsByRef ? OpCodes.Ldflda : OpCodes.Ldfld, fieldInfo);
}
continue;
}
// state is special too since each patch has its own local var
if (patchParam.Name == STATE_VAR)
{
var ldlocCode = patchParam.ParameterType.IsByRef ? OpCodes.Ldloca : OpCodes.Ldloc;
if (variables.TryGetValue(patch.DeclaringType.FullName, out var stateVar))
{
emitter.Emit(ldlocCode, stateVar);
}
else
{
emitter.Emit(OpCodes.Ldnull);
}
continue;
}
// treat __result var special
if (patchParam.Name == RESULT_VAR)
{
var returnType = AccessTools.GetReturnedType(original);
if (returnType == typeof(void))
{
throw new Exception($"Cannot get result from void method {original.FullDescription()}");
}
var resultType = patchParam.ParameterType;
if (resultType.IsByRef)
{
resultType = resultType.GetElementType();
}
if (resultType.IsAssignableFrom(returnType) == false)
{
throw new Exception($"Cannot assign method return type {returnType.FullName} to {RESULT_VAR} type {resultType.FullName} for method {original.FullDescription()}");
}
var ldlocCode = patchParam.ParameterType.IsByRef ? OpCodes.Ldloca : OpCodes.Ldloc;
emitter.Emit(ldlocCode, variables[RESULT_VAR]);
continue;
}
// any other declared variables
if (variables.TryGetValue(patchParam.Name, out var localBuilder))
{
var ldlocCode = patchParam.ParameterType.IsByRef ? OpCodes.Ldloca : OpCodes.Ldloc;
emitter.Emit(ldlocCode, localBuilder);
continue;
}
int idx;
if (patchParam.Name.StartsWith(PARAM_INDEX_PREFIX, StringComparison.Ordinal))
{
var val = patchParam.Name.Substring(PARAM_INDEX_PREFIX.Length);
if (!int.TryParse(val, out idx))
{
throw new Exception($"Parameter {patchParam.Name} does not contain a valid index");
}
if (idx < 0 || idx >= originalParameters.Length)
{
throw new Exception($"No parameter found at index {idx}");
}
}
else
{
idx = patch.GetArgumentIndex(originalParameterNames, patchParam);
if (idx == -1)
{
throw new Exception($"Parameter \"{patchParam.Name}\" not found in method {original.FullDescription()}");
}
}
// original -> patch opcode
// --------------------------------------
// 1 normal -> normal : LDARG
// 2 normal -> ref/out : LDARGA
// 3 ref/out -> normal : LDARG, LDIND_x
// 4 ref/out -> ref/out : LDARG
//
var originalIsNormal = originalParameters[idx].IsOut == false && originalParameters[idx].ParameterType.IsByRef == false;
var patchIsNormal = patchParam.IsOut == false && patchParam.ParameterType.IsByRef == false;
var patchArgIndex = idx + (isInstance ? 1 : 0) + (useStructReturnBuffer ? 1 : 0);
// Case 1 + 4
if (originalIsNormal == patchIsNormal)
{
emitter.Emit(OpCodes.Ldarg, patchArgIndex);
continue;
}
// Case 2
if (originalIsNormal && patchIsNormal == false)
{
emitter.Emit(OpCodes.Ldarga, patchArgIndex);
continue;
}
// Case 3
emitter.Emit(OpCodes.Ldarg, patchArgIndex);
emitter.Emit(LoadIndOpCodeFor(originalParameters[idx].ParameterType));
}
}
internal static DynamicMethod CreateDynamicMethod(MethodBase original, string suffix)
{
if (original == null)
{
throw new ArgumentNullException(nameof(original));
}
var patchName = original.Name + suffix;
patchName = patchName.Replace("<>", "");
var parameters = original.GetParameters();
var parameterTypes = parameters.Types().ToList();
if (original.IsStatic == false)
{
if (AccessTools.IsStruct(original.DeclaringType))
{
parameterTypes.Insert(0, original.DeclaringType.MakeByRefType());
}
else
{
parameterTypes.Insert(0, original.DeclaringType);
}
}
var firstArgIsReturnBuffer = NativeThisPointer.NeedsNativeThisPointerFix(original);
if (firstArgIsReturnBuffer)
{
parameterTypes.Insert(0, typeof(IntPtr));
}
var returnType = firstArgIsReturnBuffer ? typeof(void) : AccessTools.GetReturnedType(original);
// DynamicMethod does not support byref return types
if (returnType == null || returnType.IsByRef)
{
return(null);
}
DynamicMethod method;
try
{
method = new DynamicMethod(
patchName,
MethodAttributes.Public | MethodAttributes.Static,
CallingConventions.Standard,
returnType,
parameterTypes.ToArray(),
original.DeclaringType,
true
);
}
catch (Exception)
{
return(null);
}
var offset = (original.IsStatic ? 0 : 1) + (firstArgIsReturnBuffer ? 1 : 0);
for (var i = 0; i < parameters.Length; i++)
{
method.DefineParameter(i + offset, parameters[i].Attributes, parameters[i].Name);
}
return(method);
}
internal static DynamicMethodDefinition CreateDynamicMethod(MethodBase original, string suffix, bool debug)
{
if (original == null)
{
throw new ArgumentNullException(nameof(original));
}
var patchName = original.Name + suffix;
patchName = patchName.Replace("<>", "");
var parameters = original.GetParameters();
var parameterTypes = parameters.Types().ToList();
var useStructReturnBuffer = StructReturnBuffer.NeedsFix(original);
if (useStructReturnBuffer)
{
parameterTypes.Insert(0, typeof(IntPtr));
}
if (original.IsStatic == false)
{
if (AccessTools.IsStruct(original.DeclaringType))
{
parameterTypes.Insert(0, original.DeclaringType.MakeByRefType());
}
else
{
parameterTypes.Insert(0, original.DeclaringType);
}
}
var returnType = useStructReturnBuffer ? typeof(void) : AccessTools.GetReturnedType(original);
var method = new DynamicMethodDefinition(
patchName,
returnType,
parameterTypes.ToArray()
)
{
OwnerType = original.DeclaringType
};
#if NETSTANDARD2_0 || NETCOREAPP2_0
#else
var offset = (original.IsStatic ? 0 : 1) + (useStructReturnBuffer ? 1 : 0);
if (useStructReturnBuffer)
{
method.Definition.Parameters[original.IsStatic ? 0 : 1].Name = "retbuf";
}
if (!original.IsStatic)
{
method.Definition.Parameters[0].Name = "this";
}
for (var i = 0; i < parameters.Length; i++)
{
var param = method.Definition.Parameters[i + offset];
param.Attributes = (Mono.Cecil.ParameterAttributes)parameters[i].Attributes;
param.Name = parameters[i].Name;
}
#endif
if (debug)
{
FileLog.LogBuffered($"### Replacement: static {returnType.FullDescription()} {original.DeclaringType.FullName}::{patchName}{parameterTypes.ToArray().Description()}");
}
return(method);
}
