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)); } }