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()); }
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); }
LocalBuilder DeclareLocalVariable(Type type, bool isReturnValue = false) { if (type.IsByRef && isReturnValue == false) { type = type.GetElementType(); } if (type.IsEnum) { type = Enum.GetUnderlyingType(type); } if (AccessTools.IsClass(type)) { var v = il.DeclareLocal(type); emitter.Emit(OpCodes.Ldnull); emitter.Emit(OpCodes.Stloc, v); return(v); } if (AccessTools.IsStruct(type)) { var v = il.DeclareLocal(type); emitter.Emit(OpCodes.Ldloca, v); emitter.Emit(OpCodes.Initobj, type); return(v); } if (AccessTools.IsValue(type)) { var v = il.DeclareLocal(type); if (type == typeof(float)) { emitter.Emit(OpCodes.Ldc_R4, (float)0); } else if (type == typeof(double)) { emitter.Emit(OpCodes.Ldc_R8, (double)0); } else if (type == typeof(long) || type == typeof(ulong)) { emitter.Emit(OpCodes.Ldc_I8, (long)0); } else { emitter.Emit(OpCodes.Ldc_I4, 0); } emitter.Emit(OpCodes.Stloc, v); return(v); } return(null); }
internal static LocalBuilder DeclareLocalVariable(ILGenerator generator, Type type) { if (type.IsByRef) { type = type.GetElementType(); } if (type.IsEnum) { type = Enum.GetUnderlyingType(type); } if (AccessTools.IsClass(type)) { var v = generator.DeclareLocal(type); Emitter.Emit(generator, OpCodes.Ldnull); Emitter.Emit(generator, OpCodes.Stloc, v); return(v); } if (AccessTools.IsStruct(type)) { var v = generator.DeclareLocal(type); Emitter.Emit(generator, OpCodes.Ldloca, v); Emitter.Emit(generator, OpCodes.Initobj, type); return(v); } if (AccessTools.IsValue(type)) { var v = generator.DeclareLocal(type); if (type == typeof(float)) { Emitter.Emit(generator, OpCodes.Ldc_R4, (float)0); } else if (type == typeof(double)) { Emitter.Emit(generator, OpCodes.Ldc_R8, (double)0); } else if (type == typeof(long) || type == typeof(ulong)) { Emitter.Emit(generator, OpCodes.Ldc_I8, (long)0); } else { Emitter.Emit(generator, OpCodes.Ldc_I4, 0); } Emitter.Emit(generator, OpCodes.Stloc, v); return(v); } return(null); }
void InitializeOutParameter(int argIndex, Type type) { if (type.IsByRef) { type = type.GetElementType(); } emitter.Emit(OpCodes.Ldarg, argIndex); if (AccessTools.IsStruct(type)) { emitter.Emit(OpCodes.Initobj, type); return; } if (AccessTools.IsValue(type)) { if (type == typeof(float)) { emitter.Emit(OpCodes.Ldc_R4, (float)0); emitter.Emit(OpCodes.Stind_R4); return; } else if (type == typeof(double)) { emitter.Emit(OpCodes.Ldc_R8, (double)0); emitter.Emit(OpCodes.Stind_R8); return; } else if (type == typeof(long)) { emitter.Emit(OpCodes.Ldc_I8, (long)0); emitter.Emit(OpCodes.Stind_I8); return; } else { emitter.Emit(OpCodes.Ldc_I4, 0); emitter.Emit(OpCodes.Stind_I4); return; } } // class or default emitter.Emit(OpCodes.Ldnull); emitter.Emit(OpCodes.Stind_Ref); }
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()); }
static bool PrefixAffectsOriginal(MethodInfo fix) { if (fix.ReturnType == typeof(bool)) { return(true); } return(fix.GetParameters().Any(p => { var name = p.Name; var type = p.ParameterType; if (name == INSTANCE_PARAM) { return false; } if (name == ORIGINAL_METHOD_PARAM) { return false; } if (name == STATE_VAR) { return false; } if (p.IsOut) { return true; } if (type.IsByRef) { return true; } if (AccessTools.IsValue(type) == false && AccessTools.IsStruct(type) == false) { return true; } return false; })); }
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); }
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 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); }
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); }