public static LocalBuilder DeclareLocalVariable(ILGenerator il, Type type)
{
if (type.IsByRef)
{
type = type.GetElementType();
}
if (AccessTools.IsClass(type))
{
var v = il.DeclareLocal(type);
Emitter.LogLocalVariable(il, v);
Emitter.Emit(il, OpCodes.Ldnull);
Emitter.Emit(il, OpCodes.Stloc, v);
return(v);
}
if (AccessTools.IsStruct(type))
{
var v = il.DeclareLocal(type);
Emitter.LogLocalVariable(il, v);
Emitter.Emit(il, OpCodes.Ldloca, v);
Emitter.Emit(il, OpCodes.Initobj, type);
return(v);
}
if (AccessTools.IsValue(type))
{
var v = il.DeclareLocal(type);
Emitter.LogLocalVariable(il, v);
if (type == typeof(float))
{
Emitter.Emit(il, OpCodes.Ldc_R4, (float)0);
}
else if (type == typeof(double))
{
Emitter.Emit(il, OpCodes.Ldc_R8, (double)0);
}
else if (type == typeof(long))
{
Emitter.Emit(il, OpCodes.Ldc_I8, (long)0);
}
else
{
Emitter.Emit(il, OpCodes.Ldc_I4, 0);
}
Emitter.Emit(il, OpCodes.Stloc, v);
return(v);
}
return(null);
}
static bool AddPostfixes(ILGenerator il, MethodBase original, List <MethodInfo> postfixes, Dictionary <string, LocalBuilder> variables)
{
/*if(resultVariable != null && postfixes.Count == 1)
* {
* var fix = postfixes[0];
*
* EmitCallParameter(il, original, fix, variables);
* Emitter.Emit(il, OpCodes.Call, fix);
*
* if (fix.ReturnType != typeof(void))
* {
* if (resultVariable != null)
* Emitter.Emit(il, OpCodes.Ldloc, resultVariable);
* Emitter.Emit(il, OpCodes.Ret);
* }
*
* return false;
* } */
bool ret = false;
for (int i = 0; i < postfixes.Count; i++)
{
var fix = postfixes[i];
EmitCallParameter(il, original, fix, variables);
Emitter.Emit(il, OpCodes.Call, fix);
/*
* if (fix.ReturnType != typeof(void))
* throw new Exception("Postfix patch " + fix + " has not \"void\" return type: " + fix.ReturnType);
*/
if (i == postfixes.Count - 1)
{
ret = fix.ReturnType != typeof(void);
}
}
return(ret);
}
static bool AddPrefixes(ILGenerator il, MethodBase original, List <MethodInfo> prefixes, Dictionary <string, LocalBuilder> variables, Label label)
{
var canHaveJump = false;
prefixes.ForEach(fix =>
{
EmitCallParameter(il, original, fix, variables);
Emitter.Emit(il, OpCodes.Call, fix);
if (fix.ReturnType != typeof(void))
{
if (fix.ReturnType != typeof(bool))
{
throw new Exception("Prefix patch " + fix + " has not \"bool\" or \"void\" return type: " + fix.ReturnType);
}
Emitter.Emit(il, OpCodes.Brfalse, label);
canHaveJump = true;
}
});
return(canHaveJump);
}
public static DynamicMethod CreatePatchedMethod(MethodBase original, MethodInfo postfix)
{
var patch = DynamicTools.CreateDynamicMethod(original, "_Patch");
var il = patch.GetILGenerator();
var originalVariables = DynamicTools.DeclareLocalVariables(original, il);
var privateVars = new Dictionary <string, LocalBuilder>();
LocalBuilder resultVariable = null;
if (postfix != null)
{
resultVariable = DynamicTools.DeclareLocalVariable(il, AccessTools.GetReturnedType(original));
privateVars[RESULT_VAR] = resultVariable;
}
var afterOriginal1 = il.DefineLabel();
var copier = new MethodCopier(original, patch, originalVariables);
copier.Emit(afterOriginal1);
Emitter.MarkLabel(il, afterOriginal1);
if (resultVariable != null)
{
Emitter.Emit(il, OpCodes.Stloc, resultVariable);
}
AddPostfix(il, original, postfix, privateVars);
if (resultVariable != null)
{
Emitter.Emit(il, OpCodes.Ldloc, resultVariable);
}
Emitter.Emit(il, OpCodes.Ret);
DynamicTools.PrepareDynamicMethod(patch);
return(patch);
}
private static DynamicMethod CreateIl2CppShim(DynamicMethod original, Type owner)
{
var patchName = original.Name + "_il2cpp";
var parameters = original.GetParameters();
var result = parameters.Types().ToList();
var origParamTypes = result.ToArray();
var paramTypes = new Type[origParamTypes.Length];
for (int i = 0; i < paramTypes.Length; ++i)
{
paramTypes[i] = UnhollowerSupport.IsGeneratedAssemblyType(origParamTypes[i]) ? typeof(IntPtr) : origParamTypes[i];
}
var origReturnType = AccessTools.GetReturnedType(original);
var returnType = UnhollowerSupport.IsGeneratedAssemblyType(origReturnType) ? typeof(IntPtr) : origReturnType;
DynamicMethod method;
method = new DynamicMethod(
patchName,
MethodAttributes.Public | MethodAttributes.Static,
CallingConventions.Standard,
returnType,
paramTypes,
owner,
true
);
for (var i = 0; i < parameters.Length; i++)
{
method.DefineParameter(i + 1, parameters[i].Attributes, parameters[i].Name);
}
var il = method.GetILGenerator();
// Load arguments, invoking the IntPrt -> Il2CppObject constructor for IL2CPP types
for (int i = 0; i < origParamTypes.Length; ++i)
{
Emitter.Emit(il, OpCodes.Ldarg, i);
if (UnhollowerSupport.IsGeneratedAssemblyType(origParamTypes[i]))
{
Emitter.Emit(il, OpCodes.Newobj, Il2CppConstuctor(origParamTypes[i]));
}
}
// Call the original patch with the now-correct types
Emitter.Emit(il, OpCodes.Call, original);
// If needed, unwrap the return value; then return
if (UnhollowerSupport.IsGeneratedAssemblyType(origReturnType))
{
var pointerGetter = AccessTools.DeclaredProperty(UnhollowerSupport.Il2CppObjectBaseType, "Pointer").GetGetMethod();
Emitter.Emit(il, OpCodes.Call, pointerGetter);
}
Emitter.Emit(il, OpCodes.Ret);
DynamicTools.PrepareDynamicMethod(method);
return(method);
}
public static DynamicMethod CreatePatchedMethod(MethodBase original, string harmonyInstanceID, List <MethodInfo> prefixes, List <MethodInfo> postfixes, List <MethodInfo> transpilers)
{
try
{
if (HarmonyInstance.DEBUG)
{
FileLog.LogBuffered("### Patch " + original.DeclaringType + ", " + original);
}
bool isIl2Cpp = original.DeclaringType.IsSubclassOf(typeof(Il2CppObjectBase));
if (isIl2Cpp && transpilers.Count > 0)
{
throw new NotSupportedException("IL2CPP patches cannot use transpilers (got " + transpilers.Count + ")");
}
var idx = prefixes.Count() + postfixes.Count();
var patch = DynamicTools.CreateDynamicMethod(original, "_Patch" + idx, isIl2Cpp);
if (patch == null)
{
return(null);
}
var il = patch.GetILGenerator();
// for debugging
AssemblyBuilder assemblyBuilder = null;
TypeBuilder typeBuilder = null;
if (DEBUG_METHOD_GENERATION_BY_DLL_CREATION)
{
il = DynamicTools.CreateSaveableMethod(original, "_Patch" + idx, out assemblyBuilder, out typeBuilder);
}
var originalVariables = DynamicTools.DeclareLocalVariables(original, il);
var privateVars = new Dictionary <string, LocalBuilder>();
LocalBuilder resultVariable = null;
if (idx > 0)
{
resultVariable = DynamicTools.DeclareLocalVariable(il, AccessTools.GetReturnedType(original));
privateVars[RESULT_VAR] = resultVariable;
}
prefixes.ForEach(prefix =>
{
prefix.GetParameters()
.Where(patchParam => patchParam.Name == STATE_VAR)
.Do(patchParam =>
{
var privateStateVariable = DynamicTools.DeclareLocalVariable(il, patchParam.ParameterType);
privateVars[prefix.DeclaringType.FullName] = privateStateVariable;
});
});
var skipOriginalLabel = il.DefineLabel();
var canHaveJump = AddPrefixes(il, original, prefixes, privateVars, skipOriginalLabel, isIl2Cpp);
var copier = new MethodCopier(original, il, originalVariables);
foreach (var transpiler in transpilers)
{
copier.AddTranspiler(transpiler);
}
var endLabels = new List <Label>();
var endBlocks = new List <ExceptionBlock>();
copier.Finalize(endLabels, endBlocks);
foreach (var label in endLabels)
{
Emitter.MarkLabel(il, label);
}
foreach (var block in endBlocks)
{
Emitter.MarkBlockAfter(il, block);
}
if (resultVariable != null)
{
Emitter.Emit(il, OpCodes.Stloc, resultVariable);
}
if (canHaveJump)
{
Emitter.MarkLabel(il, skipOriginalLabel);
}
AddPostfixes(il, original, postfixes, privateVars, false, isIl2Cpp);
if (resultVariable != null)
{
Emitter.Emit(il, OpCodes.Ldloc, resultVariable);
}
AddPostfixes(il, original, postfixes, privateVars, true, isIl2Cpp);
Emitter.Emit(il, OpCodes.Ret);
if (HarmonyInstance.DEBUG)
{
FileLog.LogBuffered("DONE");
FileLog.LogBuffered("");
FileLog.FlushBuffer();
}
// for debugging
if (DEBUG_METHOD_GENERATION_BY_DLL_CREATION)
{
DynamicTools.SaveMethod(assemblyBuilder, typeBuilder);
return(null);
}
DynamicTools.PrepareDynamicMethod(patch);
return(patch);
}
catch (Exception ex)
{
throw new Exception("Exception from HarmonyInstance \"" + harmonyInstanceID + "\"", ex);
}
finally
{
if (HarmonyInstance.DEBUG)
{
FileLog.FlushBuffer();
}
}
}
static void EmitCallParameter(ILGenerator il, MethodBase original, MethodInfo patch, Dictionary <string, LocalBuilder> variables, bool allowFirsParamPassthrough, bool isIl2Cpp)
{
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)
{
var constructorInfo = original as ConstructorInfo;
if (constructorInfo != null)
{
Emitter.Emit(il, OpCodes.Ldtoken, constructorInfo);
Emitter.Emit(il, OpCodes.Call, getMethodMethod);
continue;
}
var methodInfo = original as MethodInfo;
if (methodInfo != null)
{
Emitter.Emit(il, OpCodes.Ldtoken, methodInfo);
Emitter.Emit(il, OpCodes.Call, getMethodMethod);
continue;
}
Emitter.Emit(il, OpCodes.Ldnull);
continue;
}
if (patchParam.Name == INSTANCE_PARAM)
{
if (original.IsStatic)
{
Emitter.Emit(il, OpCodes.Ldnull);
}
else if (patchParam.ParameterType.IsByRef)
{
Emitter.Emit(il, OpCodes.Ldarga, 0); // probably won't work or will be useless
}
else
{
Emitter.Emit(il, OpCodes.Ldarg_0);
}
continue;
}
if (patchParam.Name.StartsWith(INSTANCE_FIELD_PREFIX))
{
var fieldName = patchParam.Name.Substring(INSTANCE_FIELD_PREFIX.Length);
if (isIl2Cpp)
{
if (patchParam.ParameterType.IsByRef)
{
throw new NotSupportedException("Ref parameters to fields are not supported in IL2CPP patches");
}
var getterMethod = AccessTools.Property(original.DeclaringType, fieldName)?.GetMethod;
if (getterMethod == null)
{
throw new ArgumentException("No such field defined in class " + original.DeclaringType.FullName, fieldName);
}
if (!getterMethod.IsStatic)
{
Emitter.Emit(il, OpCodes.Ldarg_0);
}
var opcode = getterMethod.IsVirtual ? OpCodes.Callvirt : OpCodes.Call;
Emitter.Emit(il, opcode, getterMethod);
}
else
{
FieldInfo fieldInfo;
if (fieldName.All(char.IsDigit))
{
fieldInfo = AccessTools.Field(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)
{
if (patchParam.ParameterType.IsByRef)
{
Emitter.Emit(il, OpCodes.Ldsflda, fieldInfo);
}
else
{
Emitter.Emit(il, OpCodes.Ldsfld, fieldInfo);
}
}
else
{
if (patchParam.ParameterType.IsByRef)
{
Emitter.Emit(il, OpCodes.Ldarg_0);
Emitter.Emit(il, OpCodes.Ldflda, fieldInfo);
}
else
{
Emitter.Emit(il, OpCodes.Ldarg_0);
Emitter.Emit(il, OpCodes.Ldfld, fieldInfo);
}
}
}
continue;
}
if (patchParam.Name == STATE_VAR)
{
var ldlocCode = patchParam.ParameterType.IsByRef ? OpCodes.Ldloca : OpCodes.Ldloc;
Emitter.Emit(il, ldlocCode, variables[patch.DeclaringType.FullName]);
continue;
}
if (patchParam.Name == RESULT_VAR)
{
if (AccessTools.GetReturnedType(original) == typeof(void))
{
throw new Exception("Cannot get result from void method " + original.FullDescription());
}
var ldlocCode = patchParam.ParameterType.IsByRef ? OpCodes.Ldloca : OpCodes.Ldloc;
Emitter.Emit(il, ldlocCode, variables[RESULT_VAR]);
continue;
}
int idx;
if (patchParam.Name.StartsWith(PARAM_INDEX_PREFIX))
{
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 = GetArgumentIndex(patch, 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);
// Case 1 + 4
if (originalIsNormal == patchIsNormal)
{
Emitter.Emit(il, OpCodes.Ldarg, patchArgIndex);
continue;
}
// Case 2
if (originalIsNormal && patchIsNormal == false)
{
Emitter.Emit(il, OpCodes.Ldarga, patchArgIndex);
continue;
}
// Case 3
Emitter.Emit(il, OpCodes.Ldarg, patchArgIndex);
Emitter.Emit(il, LoadIndOpCodeFor(originalParameters[idx].ParameterType));
}
}
static void EmitCallParameter(ILGenerator il, MethodBase original, MethodInfo patch, Dictionary <string, LocalBuilder> variables)
{
var isInstance = original.IsStatic == false;
var originalParameters = original.GetParameters();
var originalParameterNames = originalParameters.Select(p => p.Name).ToArray();
foreach (var patchParam in patch.GetParameters())
{
if (patchParam.Name == INSTANCE_PARAM)
{
if (!isInstance)
{
throw new Exception("Cannot get instance from static method " + original);
}
if (patchParam.ParameterType.IsByRef)
{
Emitter.Emit(il, OpCodes.Ldarga, 0); // probably won't work or will be useless
}
else
{
Emitter.Emit(il, OpCodes.Ldarg_0);
}
continue;
}
if (patchParam.Name == STATE_VAR)
{
var ldlocCode = patchParam.ParameterType.IsByRef ? OpCodes.Ldloca : OpCodes.Ldloc;
Emitter.Emit(il, ldlocCode, variables[patch.DeclaringType.FullName]);
continue;
}
if (patchParam.Name == RESULT_VAR)
{
if (AccessTools.GetReturnedType(original) == typeof(void))
{
throw new Exception("Cannot get result from void method " + original);
}
var ldlocCode = patchParam.ParameterType.IsByRef ? OpCodes.Ldloca : OpCodes.Ldloc;
Emitter.Emit(il, ldlocCode, variables[RESULT_VAR]);
continue;
}
var idx = Array.IndexOf(originalParameterNames, patchParam.Name);
if (idx == -1)
{
throw new Exception("Parameter \"" + patchParam.Name + "\" not found in method " + original);
}
// 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);
// Case 1 + 4
if (originalIsNormal == patchIsNormal)
{
Emitter.Emit(il, OpCodes.Ldarg, patchArgIndex);
continue;
}
// Case 2
if (originalIsNormal && patchIsNormal == false)
{
Emitter.Emit(il, OpCodes.Ldarga, patchArgIndex);
continue;
}
// Case 3
Emitter.Emit(il, OpCodes.Ldarg, patchArgIndex);
Emitter.Emit(il, LoadIndOpCodeFor(originalParameters[idx].ParameterType));
}
}
private static void ConvertArgument(ILGenerator il, Type paramType, ref LocalBuilder byRefLocal)
{
if (paramType.IsValueType)
{
return;
}
if (paramType.IsByRef)
{
Type elementType = paramType.GetElementType();
if (paramType.GetElementType() == typeof(string))
{
// byRefLocal = Il2CppStringToManaged(*ptr);
// return ref byRefLocal;
byRefLocal = il.DeclareLocal(elementType);
Emitter.Emit(il, OpCodes.Ldind_I);
Emitter.Emit(il, OpCodes.Call, UnhollowerSupport.Il2CppStringToManagedMethod);
Emitter.Emit(il, OpCodes.Stloc, byRefLocal);
Emitter.Emit(il, OpCodes.Ldloca, byRefLocal);
}
else if (UnhollowerSupport.IsGeneratedAssemblyType(elementType))
{
// byRefLocal = *ptr == 0 ? null : new SomeType(*ptr);
// return ref byRefLocal;
Label ptrNonZero = il.DefineLabel();
Label done = il.DefineLabel();
byRefLocal = il.DeclareLocal(elementType);
Emitter.Emit(il, OpCodes.Ldind_I);
Emitter.Emit(il, OpCodes.Dup);
Emitter.Emit(il, OpCodes.Brtrue_S, ptrNonZero);
Emitter.Emit(il, OpCodes.Pop);
Emitter.Emit(il, OpCodes.Br_S, done);
Emitter.MarkLabel(il, ptrNonZero);
Emitter.Emit(il, OpCodes.Newobj, Il2CppConstuctor(elementType));
Emitter.Emit(il, OpCodes.Stloc, byRefLocal);
Emitter.MarkLabel(il, done);
Emitter.Emit(il, OpCodes.Ldloca, byRefLocal);
}
}
else if (paramType == typeof(string))
{
// return Il2CppStringToManaged(ptr);
Emitter.Emit(il, OpCodes.Call, UnhollowerSupport.Il2CppStringToManagedMethod);
}
else if (UnhollowerSupport.IsGeneratedAssemblyType(paramType))
{
// return ptr == 0 ? null : new SomeType(ptr);
Label ptrNonZero = il.DefineLabel();
Label done = il.DefineLabel();
Emitter.Emit(il, OpCodes.Dup);
Emitter.Emit(il, OpCodes.Brtrue_S, ptrNonZero);
Emitter.Emit(il, OpCodes.Pop);
Emitter.Emit(il, OpCodes.Ldnull);
Emitter.Emit(il, OpCodes.Br_S, done);
Emitter.MarkLabel(il, ptrNonZero);
Emitter.Emit(il, OpCodes.Newobj, Il2CppConstuctor(paramType));
Emitter.MarkLabel(il, done);
}
}
private static DynamicMethod CreateIl2CppShim(DynamicMethod patch, MethodBase original)
{
var patchName = patch.Name + "_il2cpp";
var parameters = patch.GetParameters();
var result = parameters.Types().ToList();
var origParamTypes = result.ToArray();
var paramTypes = new Type[origParamTypes.Length];
for (int i = 0; i < paramTypes.Length; ++i)
{
paramTypes[i] = Il2CppTypeForPatchType(origParamTypes[i]);
}
var origReturnType = AccessTools.GetReturnedType(patch);
var returnType = Il2CppTypeForPatchType(origReturnType);
DynamicMethod method = new DynamicMethod(
patchName,
MethodAttributes.Public | MethodAttributes.Static,
CallingConventions.Standard,
returnType,
paramTypes,
original.DeclaringType,
true
);
for (var i = 0; i < parameters.Length; i++)
{
method.DefineParameter(i + 1, parameters[i].Attributes, parameters[i].Name);
}
var il = method.GetILGenerator();
LocalBuilder[] byRefValues = new LocalBuilder[parameters.Length];
LocalBuilder returnLocal = null;
if (origReturnType != typeof(void))
{
returnLocal = il.DeclareLocal(origReturnType);
Emitter.LogLocalVariable(il, returnLocal);
}
LocalBuilder exceptionLocal = il.DeclareLocal(typeof(Exception));
Emitter.LogLocalVariable(il, exceptionLocal);
// Start a try-block for the call to the original patch
Emitter.MarkBlockBefore(il, new ExceptionBlock(ExceptionBlockType.BeginExceptionBlock, null), out _);
// Load arguments, invoking the IntPrt -> Il2CppObject constructor for IL2CPP types
for (int i = 0; i < origParamTypes.Length; ++i)
{
Emitter.Emit(il, OpCodes.Ldarg, i);
ConvertArgument(il, origParamTypes[i], ref byRefValues[i]);
if (byRefValues[i] != null)
{
Emitter.LogLocalVariable(il, byRefValues[i]);
}
}
// Call the original patch with the now-correct types
Emitter.Emit(il, OpCodes.Call, patch);
// Store the result, if any
if (returnLocal != null)
{
Emitter.Emit(il, OpCodes.Stloc, returnLocal);
}
// Catch any exceptions that may have been thrown
Emitter.MarkBlockBefore(il, new ExceptionBlock(ExceptionBlockType.BeginCatchBlock, typeof(Exception)), out _);
// MelonModLogger.LogError("Exception in ...\n" + exception.ToString());
Emitter.Emit(il, OpCodes.Stloc, exceptionLocal);
Emitter.Emit(il, OpCodes.Ldstr, $"Exception in Harmony patch of method {original.FullDescription()}:\n");
Emitter.Emit(il, OpCodes.Ldloc, exceptionLocal);
Emitter.Emit(il, OpCodes.Call, AccessTools.DeclaredMethod(typeof(Exception), "ToString", new Type[0]));
Emitter.Emit(il, OpCodes.Call, AccessTools.DeclaredMethod(typeof(string), "Concat", new Type[] { typeof(string), typeof(string) }));
Emitter.Emit(il, OpCodes.Call, AccessTools.DeclaredMethod(typeof(MelonModLogger), "LogError", new Type[] { typeof(string) }));
// Close the exception block
Emitter.MarkBlockAfter(il, new ExceptionBlock(ExceptionBlockType.EndExceptionBlock, null));
// Write back the pointers of ref arguments
for (int i = 0; i < parameters.Length; ++i)
{
if (byRefValues[i] == null)
{
continue;
}
Emitter.Emit(il, OpCodes.Ldarg, i); // -> [intptr*]
Emitter.Emit(il, OpCodes.Ldloc, byRefValues[i]); // -> [intptr*, obj]
if (origParamTypes[i].GetElementType() == typeof(string))
{
Emitter.Emit(il, OpCodes.Call, UnhollowerSupport.ManagedStringToIl2CppMethod); // -> [intptr*, intptr]
}
else
{
Emitter.Emit(il, OpCodes.Call, UnhollowerSupport.Il2CppObjectBaseToPtrMethod); // -> [intptr*, intptr]
}
Emitter.Emit(il, OpCodes.Stind_I); // -> []
}
// Load the return value, if any, and unwrap it if required
if (returnLocal != null)
{
Emitter.Emit(il, OpCodes.Ldloc, returnLocal);
ConvertReturnValue(il, origReturnType);
}
Emitter.Emit(il, OpCodes.Ret);
DynamicTools.PrepareDynamicMethod(method);
return(method);
}
internal void FinalizeILCodes(List <MethodInfo> transpilers, List <Label> endLabels, List <ExceptionBlock> endBlocks)
{
if (generator == null)
{
return;
}
// pass1 - define labels and add them to instructions that are target of a jump
//
foreach (var ilInstruction in ilInstructions)
{
switch (ilInstruction.opcode.OperandType)
{
case OperandType.InlineSwitch:
{
var targets = ilInstruction.operand as ILInstruction[];
if (targets != null)
{
var labels = new List <Label>();
foreach (var target in targets)
{
var label = generator.DefineLabel();
target.labels.Add(label);
labels.Add(label);
}
ilInstruction.argument = labels.ToArray();
}
break;
}
case OperandType.ShortInlineBrTarget:
case OperandType.InlineBrTarget:
{
var target = ilInstruction.operand as ILInstruction;
if (target != null)
{
var label = generator.DefineLabel();
target.labels.Add(label);
ilInstruction.argument = label;
}
break;
}
}
}
// pass2 - filter through all processors
//
var codeTranspiler = new CodeTranspiler(ilInstructions);
transpilers.Do(transpiler => codeTranspiler.Add(transpiler));
var codeInstructions = codeTranspiler.GetResult(generator, method);
if (HarmonyInstance.DEBUG)
{
Emitter.LogComment(generator, "start original");
}
// pass3 - log out all new local variables
//
var savedLog = FileLog.GetBuffer(true);
Emitter.AllLocalVariables(generator).Do(local => Emitter.LogLocalVariable(generator, local));
FileLog.LogBuffered(savedLog);
// pass4 - remove RET if it appears at the end
//
while (true)
{
var lastInstruction = codeInstructions.LastOrDefault();
if (lastInstruction == null || lastInstruction.opcode != OpCodes.Ret)
{
break;
}
// remember any existing labels
endLabels.AddRange(lastInstruction.labels);
codeInstructions.RemoveAt(codeInstructions.Count - 1);
}
// pass5 - mark labels and exceptions and emit codes
//
var idx = 0;
codeInstructions.Do(codeInstruction =>
{
// mark all labels
codeInstruction.labels.Do(label => Emitter.MarkLabel(generator, label));
// start all exception blocks
// TODO: we ignore the resulting label because we have no way to use it
//
codeInstruction.blocks.Do(block => {
Label?label;
Emitter.MarkBlockBefore(generator, block, out label);
});
var code = codeInstruction.opcode;
var operand = codeInstruction.operand;
// replace RET with a jump to the end (outside this code)
if (code == OpCodes.Ret)
{
var endLabel = generator.DefineLabel();
code = OpCodes.Br;
operand = endLabel;
endLabels.Add(endLabel);
}
// replace short jumps with long ones (can be optimized but requires byte counting, not instruction counting)
if (shortJumps.TryGetValue(code, out var longJump))
{
code = longJump;
}
var emitCode = true;
//if (code == OpCodes.Leave || code == OpCodes.Leave_S)
//{
// // skip LEAVE on EndExceptionBlock
// if (codeInstruction.blocks.Any(block => block.blockType == ExceptionBlockType.EndExceptionBlock))
// emitCode = false;
// // skip LEAVE on next instruction starts a new exception handler and we are already in
// if (idx < instructions.Length - 1)
// if (instructions[idx + 1].blocks.Any(block => block.blockType != ExceptionBlockType.EndExceptionBlock))
// emitCode = false;
//}
if (emitCode)
{
switch (code.OperandType)
{
case OperandType.InlineNone:
Emitter.Emit(generator, code);
break;
case OperandType.InlineSig:
// TODO the following will fail because we do not convert the token (operand)
// All the decompilers can show the arguments correctly, we just need to find out how
//
if (operand == null)
{
throw new Exception("Wrong null argument: " + codeInstruction);
}
if ((operand is int) == false)
{
throw new Exception("Wrong Emit argument type " + operand.GetType() + " in " + codeInstruction);
}
Emitter.Emit(generator, code, (int)operand);
/*
* // the following will only work if we can convert the original signature token to the required arguments
* //
* var callingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall;
* var returnType = typeof(object);
* var parameterTypes = new[] { typeof(object) };
* Emitter.EmitCalli(generator, code, callingConvention, returnType, parameterTypes);
*
* var callingConventions = System.Reflection.CallingConventions.Standard;
* var optionalParameterTypes = new[] { typeof(object) };
* Emitter.EmitCalli(generator, code, callingConventions, returnType, parameterTypes, optionalParameterTypes);
*/
break;
default:
if (operand == null)
{
throw new Exception("Wrong null argument: " + codeInstruction);
}
var emitMethod = EmitMethodForType(operand.GetType());
if (emitMethod == null)
{
throw new Exception("Unknown Emit argument type " + operand.GetType() + " in " + codeInstruction);
}
if (HarmonyInstance.DEBUG)
{
FileLog.LogBuffered(Emitter.CodePos(generator) + code + " " + Emitter.FormatArgument(operand));
}
emitMethod.Invoke(generator, new object[] { code, operand });
break;
}
}
codeInstruction.blocks.Do(block => Emitter.MarkBlockAfter(generator, block));
idx++;
});
if (HarmonyInstance.DEBUG)
{
Emitter.LogComment(generator, "end original");
}
}
public static DynamicMethod CreatePatchedMethod(MethodBase original, List <MethodInfo> prefixes, List <MethodInfo> postfixes, List <TranspilerImpl> transpilers, PatchFlags flags)
{
if (HarmonyInstance.DEBUG)
{
FileLog.Log("PATCHING " + original.DeclaringType + " " + original);
}
var idx = prefixes.Count() + postfixes.Count();
var patch = DynamicTools.CreateDynamicMethod(original, "_Patch" + idx);
var il = patch.GetILGenerator();
var originalVariables = DynamicTools.DeclareLocalVariables(original, il);
var privateVars = new Dictionary <string, LocalBuilder>();
LocalBuilder resultVariable = null;
if (idx > 0)
{
resultVariable = DynamicTools.DeclareLocalVariable(il, AccessTools.GetReturnedType(original));
privateVars[RESULT_VAR] = resultVariable;
}
prefixes.ForEach(prefix =>
{
prefix.GetParameters()
.Where(patchParam => patchParam.Name == STATE_VAR)
.Do(patchParam =>
{
var privateStateVariable = DynamicTools.DeclareLocalVariable(il, patchParam.ParameterType);
privateVars[prefix.DeclaringType.FullName] = privateStateVariable;
});
});
var afterOriginal1 = il.DefineLabel();
var afterOriginal2 = il.DefineLabel();
bool canHaveJump = false;
if (flags.HasFlag(PatchFlags.PF_Detour) == false)
{
canHaveJump = AddPrefixes(il, original, prefixes, privateVars, afterOriginal2);
if (flags.HasFlag(PatchFlags.PF_NoOrigin) == false)
{
var copier = new MethodCopier(original, patch, originalVariables);
foreach (var transpiler in transpilers)
{
copier.AddTranspiler(transpiler);
}
copier.Emit(afterOriginal1);
Emitter.MarkLabel(il, afterOriginal1);
if (resultVariable != null)
{
Emitter.Emit(il, OpCodes.Stloc, resultVariable);
}
}
}
if (canHaveJump)
{
Emitter.MarkLabel(il, afterOriginal2);
}
if (AddPostfixes(il, original, postfixes, privateVars))
{
if (resultVariable != null)
{
Emitter.Emit(il, OpCodes.Stloc, resultVariable);
}
}
if (resultVariable != null)
{
Emitter.Emit(il, OpCodes.Ldloc, resultVariable);
}
Emitter.Emit(il, OpCodes.Ret);
if (HarmonyInstance.DEBUG)
{
FileLog.Log("DONE");
FileLog.Log("");
}
DynamicTools.PrepareDynamicMethod(patch);
return(patch);
}
static void EmitCallParameter(ILGenerator il, MethodBase original, 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();
var firstArgIsReturnBuffer = NativeThisPointer.NeedsNativeThisPointerFix(original);
// 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)
{
var constructorInfo = original as ConstructorInfo;
if (constructorInfo != null)
{
Emitter.Emit(il, OpCodes.Ldtoken, constructorInfo);
Emitter.Emit(il, OpCodes.Call, getMethodMethod);
continue;
}
var methodInfo = original as MethodInfo;
if (methodInfo != null)
{
Emitter.Emit(il, OpCodes.Ldtoken, methodInfo);
Emitter.Emit(il, OpCodes.Call, getMethodMethod);
continue;
}
Emitter.Emit(il, OpCodes.Ldnull);
continue;
}
if (patchParam.Name == INSTANCE_PARAM)
{
if (original.IsStatic)
{
Emitter.Emit(il, OpCodes.Ldnull);
}
else
{
var instanceIsRef = AccessTools.IsStruct(original.DeclaringType);
var parameterIsRef = patchParam.ParameterType.IsByRef;
if (instanceIsRef == parameterIsRef)
{
Emitter.Emit(il, firstArgIsReturnBuffer ? OpCodes.Ldarg_1 : OpCodes.Ldarg_0);
}
if (instanceIsRef && parameterIsRef == false)
{
Emitter.Emit(il, firstArgIsReturnBuffer ? OpCodes.Ldarg_1 : OpCodes.Ldarg_0);
Emitter.Emit(il, OpCodes.Ldobj, original.DeclaringType);
}
if (instanceIsRef == false && parameterIsRef)
{
Emitter.Emit(il, OpCodes.Ldarga, firstArgIsReturnBuffer ? 1 : 0);
}
}
continue;
}
if (patchParam.Name.StartsWith(INSTANCE_FIELD_PREFIX))
{
var fieldName = patchParam.Name.Substring(INSTANCE_FIELD_PREFIX.Length);
FieldInfo fieldInfo;
if (fieldName.All(char.IsDigit))
{
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.DeclaredField(original.DeclaringType, fieldName);
if (fieldInfo == null)
{
throw new ArgumentException("No such field defined in class " + original.DeclaringType.FullName, fieldName);
}
}
if (fieldInfo.IsStatic)
{
Emitter.Emit(il, patchParam.ParameterType.IsByRef ? OpCodes.Ldsflda : OpCodes.Ldsfld, fieldInfo);
}
else
{
Emitter.Emit(il, firstArgIsReturnBuffer ? OpCodes.Ldarg_1 : OpCodes.Ldarg_0);
Emitter.Emit(il, patchParam.ParameterType.IsByRef ? OpCodes.Ldflda : OpCodes.Ldfld, fieldInfo);
}
continue;
}
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(il, ldlocCode, stateVar);
}
else
{
Emitter.Emit(il, OpCodes.Ldnull);
}
continue;
}
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(il, ldlocCode, variables[RESULT_VAR]);
continue;
}
int idx;
if (patchParam.Name.StartsWith(PARAM_INDEX_PREFIX))
{
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 = GetArgumentIndex(patch, 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) + (firstArgIsReturnBuffer ? 1 : 0);
// Case 1 + 4
if (originalIsNormal == patchIsNormal)
{
Emitter.Emit(il, OpCodes.Ldarg, patchArgIndex);
continue;
}
// Case 2
if (originalIsNormal && patchIsNormal == false)
{
Emitter.Emit(il, OpCodes.Ldarga, patchArgIndex);
continue;
}
// Case 3
Emitter.Emit(il, OpCodes.Ldarg, patchArgIndex);
Emitter.Emit(il, LoadIndOpCodeFor(originalParameters[idx].ParameterType));
}
}
public static DynamicMethod CreatePatchedMethod(MethodBase original, string harmonyInstanceID, List <MethodInfo> prefixes, List <MethodInfo> postfixes, List <MethodInfo> transpilers)
{
Memory.MarkForNoInlining(original);
if (original == null)
{
throw new ArgumentNullException(nameof(original), "Original method is null. Did you specify it correctly?");
}
try
{
if (HarmonyInstance.DEBUG)
{
FileLog.LogBuffered("### Patch " + original.DeclaringType + ", " + original);
FileLog.FlushBuffer();
}
var idx = prefixes.Count() + postfixes.Count();
var firstArgIsReturnBuffer = NativeThisPointer.NeedsNativeThisPointerFix(original);
var returnType = AccessTools.GetReturnedType(original);
var patch = DynamicTools.CreateDynamicMethod(original, "_Patch" + idx);
if (patch == null)
{
return(null);
}
var il = patch.GetILGenerator();
var originalVariables = DynamicTools.DeclareLocalVariables(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).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;
});
}
});
if (firstArgIsReturnBuffer)
{
Emitter.Emit(il, original.IsStatic ? OpCodes.Ldarg_0 : OpCodes.Ldarg_1);
}
var skipOriginalLabel = il.DefineLabel();
var canHaveJump = AddPrefixes(il, original, prefixes, privateVars, skipOriginalLabel);
var copier = new MethodCopier(original, il, originalVariables);
foreach (var transpiler in transpilers)
{
copier.AddTranspiler(transpiler);
}
var endLabels = new List <Label>();
var endBlocks = new List <ExceptionBlock>();
copier.Finalize(endLabels, endBlocks);
foreach (var label in endLabels)
{
Emitter.MarkLabel(il, label);
}
foreach (var block in endBlocks)
{
Emitter.MarkBlockAfter(il, block);
}
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 (firstArgIsReturnBuffer)
{
Emitter.Emit(il, OpCodes.Stobj, returnType);
}
Emitter.Emit(il, OpCodes.Ret);
if (HarmonyInstance.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();
if (HarmonyInstance.DEBUG)
{
FileLog.Log("Exception: " + exceptionString);
}
throw new Exception(exceptionString, ex);
}
finally
{
if (HarmonyInstance.DEBUG)
{
FileLog.FlushBuffer();
}
}
}
public static DynamicMethod CreatePatchedMethod(MethodBase original, List <MethodInfo> prefixes, List <MethodInfo> postfixes, List <ICodeProcessor> processors)
{
if (MethodCopier.DEBUG_OPCODES)
{
FileLog.Log("PATCHING " + original.DeclaringType + " " + original);
}
var idx = prefixes.Count() + postfixes.Count();
var patch = DynamicTools.CreateDynamicMethod(original, "_Patch" + idx);
var il = patch.GetILGenerator();
var originalVariables = DynamicTools.DeclareLocalVariables(original, il);
var resultVariable = DynamicTools.DeclareLocalVariable(il, AccessTools.GetReturnedType(original));
var privateVars = new Dictionary <string, LocalBuilder>();
privateVars[RESULT_VAR] = resultVariable;
prefixes.ForEach(prefix =>
{
prefix.GetParameters()
.Where(patchParam => patchParam.Name == STATE_VAR)
.Do(patchParam =>
{
var privateStateVariable = DynamicTools.DeclareLocalVariable(il, patchParam.ParameterType);
privateVars[prefix.DeclaringType.FullName] = privateStateVariable;
});
});
var afterOriginal1 = il.DefineLabel();
var afterOriginal2 = il.DefineLabel();
var canHaveJump = AddPrefixes(il, original, prefixes, privateVars, afterOriginal2);
var copier = new MethodCopier(original, patch, originalVariables);
foreach (var processor in processors)
{
copier.AddReplacement(processor);
}
copier.AddReplacement(new RetToBrAfterProcessor(afterOriginal1));
copier.Emit();
Emitter.MarkLabel(il, afterOriginal1);
if (resultVariable != null)
{
Emitter.Emit(il, OpCodes.Stloc, resultVariable);
}
if (canHaveJump)
{
Emitter.MarkLabel(il, afterOriginal2);
}
AddPostfixes(il, original, postfixes, privateVars);
if (resultVariable != null)
{
Emitter.Emit(il, OpCodes.Ldloc, resultVariable);
}
Emitter.Emit(il, OpCodes.Ret);
if (MethodCopier.DEBUG_OPCODES)
{
FileLog.Log("DONE");
FileLog.Log("");
}
DynamicTools.PrepareDynamicMethod(patch);
return(patch);
}
static void EmitCallParameter(ILGenerator il, MethodBase original, 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)
{
var constructorInfo = original as ConstructorInfo;
if (constructorInfo != null)
{
Emitter.Emit(il, OpCodes.Ldtoken, constructorInfo);
Emitter.Emit(il, OpCodes.Call, getMethodMethod);
continue;
}
var methodInfo = original as MethodInfo;
if (methodInfo != null)
{
Emitter.Emit(il, OpCodes.Ldtoken, methodInfo);
Emitter.Emit(il, OpCodes.Call, getMethodMethod);
continue;
}
Emitter.Emit(il, OpCodes.Ldnull);
continue;
}
if (patchParam.Name == INSTANCE_PARAM)
{
if (original.IsStatic)
{
Emitter.Emit(il, OpCodes.Ldnull);
}
else if (patchParam.ParameterType.IsByRef)
{
Emitter.Emit(il, OpCodes.Ldarga, 0); // probably won't work or will be useless
}
else
{
Emitter.Emit(il, OpCodes.Ldarg_0);
}
continue;
}
if (patchParam.Name.StartsWith(INSTANCE_FIELD_PREFIX))
{
var fieldInfo = AccessTools.Field(original.DeclaringType, patchParam.Name.Substring(INSTANCE_FIELD_PREFIX.Length));
if (fieldInfo.IsStatic)
{
if (patchParam.ParameterType.IsByRef)
{
Emitter.Emit(il, OpCodes.Ldsflda, fieldInfo);
}
else
{
Emitter.Emit(il, OpCodes.Ldsfld, fieldInfo);
}
}
else
{
if (patchParam.ParameterType.IsByRef)
{
Emitter.Emit(il, OpCodes.Ldarg_0);
Emitter.Emit(il, OpCodes.Ldflda, fieldInfo);
}
else
{
Emitter.Emit(il, OpCodes.Ldarg_0);
Emitter.Emit(il, OpCodes.Ldfld, fieldInfo);
}
}
continue;
}
if (patchParam.Name == STATE_VAR)
{
var ldlocCode = patchParam.ParameterType.IsByRef ? OpCodes.Ldloca : OpCodes.Ldloc;
Emitter.Emit(il, ldlocCode, variables[patch.DeclaringType.FullName]);
continue;
}
if (patchParam.Name == RESULT_VAR)
{
if (AccessTools.GetReturnedType(original) == typeof(void))
{
throw new Exception("Cannot get result from void method " + original.FullDescription());
}
var ldlocCode = patchParam.ParameterType.IsByRef ? OpCodes.Ldloca : OpCodes.Ldloc;
Emitter.Emit(il, ldlocCode, variables[RESULT_VAR]);
continue;
}
var patchParamName = patchParam.Name;
var originalName = patchParam.GetParameterOverride();
if (originalName != null)
{
patchParamName = originalName;
}
else
{
originalName = patch.GetParameterOverride(patchParamName, true);
if (originalName != null)
{
patchParamName = originalName;
}
}
var idx = Array.IndexOf(originalParameterNames, patchParamName);
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);
// Case 1 + 4
if (originalIsNormal == patchIsNormal)
{
Emitter.Emit(il, OpCodes.Ldarg, patchArgIndex);
continue;
}
// Case 2
if (originalIsNormal && patchIsNormal == false)
{
Emitter.Emit(il, OpCodes.Ldarga, patchArgIndex);
continue;
}
// Case 3
Emitter.Emit(il, OpCodes.Ldarg, patchArgIndex);
Emitter.Emit(il, LoadIndOpCodeFor(originalParameters[idx].ParameterType));
}
}
