public static DynamicMethod UpdateWrapper(MethodBase original, PatchInfo patchInfo, string instanceID)
{
var sortedPrefixes = GetSortedPatchMethods(original, patchInfo.prefixes);
var sortedPostfixes = GetSortedPatchMethods(original, patchInfo.postfixes);
var sortedTranspilers = GetSortedPatchMethods(original, patchInfo.transpilers);
var replacement = MethodPatcher.CreatePatchedMethod(original, instanceID, sortedPrefixes, sortedPostfixes, sortedTranspilers);
if (replacement == null)
{
throw new MissingMethodException("Cannot create dynamic replacement for " + original.FullDescription());
}
var errorString = Memory.DetourMethod(original, replacement);
if (errorString != null)
{
throw new FormatException("Method " + original.FullDescription() + " cannot be patched. Reason: " + errorString);
}
if (UnhollowerSupport.IsGeneratedAssemblyType(original.DeclaringType))
{
var il2CppShim = CreateIl2CppShim(replacement, original.DeclaringType);
Imports.Hook(UnhollowerSupport.MethodBaseToIntPtr(original), il2CppShim.MethodHandle.GetFunctionPointer());
PatchTools.RememberObject(original, new PotatoTuple {
First = replacement, Second = il2CppShim
});
}
else
{
PatchTools.RememberObject(original, replacement); // no gc for new value + release old value to gc
}
return(replacement);
}
internal static void TryResolve(object sender, PatchManager.PatcherResolverEventArgs args)
{
if (UnhollowerSupport.IsGeneratedAssemblyType(args.Original.DeclaringType))
{
args.MethodPatcher = new HarmonyIl2CppMethodPatcher(args.Original);
}
}
private static void ConvertReturnValue(ILGenerator il, Type returnType) {
if (returnType == typeof(string)) {
Emitter.Emit(il, OpCodes.Call, UnhollowerSupport.ManagedStringToIl2CppMethod);
} else if (!returnType.IsValueType && UnhollowerSupport.IsGeneratedAssemblyType(returnType)) {
Emitter.Emit(il, OpCodes.Call, UnhollowerSupport.Il2CppObjectBaseToPtrMethod);
}
}
public static object Il2CppObjectPtrToIl2CppObjectByType(IntPtr ptr, Type type)
{
if (ptr == IntPtr.Zero)
{
throw new ArgumentException("The ptr cannot be IntPtr.Zero.");
}
if (!UnhollowerSupport.IsGeneratedAssemblyType(type))
{
throw new ArgumentException("The type must be a Generated Assembly Type.");
}
var ctor = type?.GetConstructor(BindingFlags.Instance | BindingFlags.Public, null, new[]
{
typeof(IntPtr)
}, new ParameterModifier[0]) ?? throw new MissingMethodException($"{type?.FullName}.ctor(IntPtr) not found");
try
{
var obj = ctor.Invoke(new object[] { ptr });
return(obj);
}
catch (Exception e)
{
Logger.Warn($"Exception while constructing {type.FullName}: {e}");
return(null);
}
}
public AssetBundleCreateRequest LoadAssetWithSubAssetsAsync <T>(string name) where T : Object
{
if (!UnhollowerSupport.IsGeneratedAssemblyType(typeof(T)))
{
throw new System.NullReferenceException("The type must be a Generated Assembly Type.");
}
System.IntPtr intptr = LoadAssetWithSubAssetsAsync(name, Il2CppType.Of <T>().Pointer);
return((intptr != System.IntPtr.Zero) ? new AssetBundleCreateRequest(intptr) : null);
}
public Il2CppReferenceArray <T> LoadAllAssets <T>() where T : Object
{
if (!UnhollowerSupport.IsGeneratedAssemblyType(typeof(T)))
{
throw new System.NullReferenceException("The type must be a Generated Assembly Type.");
}
System.IntPtr intptr = LoadAllAssets(Il2CppType.Of <T>().Pointer);
return((intptr != System.IntPtr.Zero) ? new Il2CppReferenceArray <T>(intptr) : null);
}
public T LoadAsset <T>(string name) where T : Object
{
if (!UnhollowerSupport.IsGeneratedAssemblyType(typeof(T)))
{
throw new System.NullReferenceException("The type must be a Generated Assembly Type.");
}
System.IntPtr intptr = LoadAsset(name, Il2CppType.Of <T>().Pointer);
return((intptr != System.IntPtr.Zero) ? UnhollowerSupport.Il2CppObjectPtrToIl2CppObject <T>(intptr) : null);
}
public static DynamicMethod UpdateWrapper(MethodBase original, PatchInfo patchInfo, string instanceID)
{
var sortedPrefixes = GetSortedPatchMethods(original, patchInfo.prefixes);
var sortedPostfixes = GetSortedPatchMethods(original, patchInfo.postfixes);
var sortedTranspilers = GetSortedPatchMethods(original, patchInfo.transpilers);
bool isIl2Cpp = UnhollowerSupport.IsGeneratedAssemblyType(original.DeclaringType);
if (isIl2Cpp)
{
if (sortedTranspilers.Count > 0)
{
throw new NotSupportedException("IL2CPP patches cannot use transpilers (got " + sortedTranspilers.Count + ")");
}
if (patchInfo.copiedMethodInfoPointer == IntPtr.Zero)
{
IntPtr origMethodPtr = UnhollowerSupport.MethodBaseToIl2CppMethodInfoPointer(original);
patchInfo.copiedMethodInfoPointer = CopyMethodInfoStruct(origMethodPtr);
HarmonySharedState.UpdatePatchInfo(original, patchInfo);
}
sortedTranspilers.Add(AccessTools.DeclaredMethod(typeof(PatchFunctions), "UnhollowerTranspiler"));
}
var replacement = MethodPatcher.CreatePatchedMethod(original, instanceID, sortedPrefixes, sortedPostfixes, sortedTranspilers);
if (replacement == null)
{
throw new MissingMethodException("Cannot create dynamic replacement for " + original.FullDescription());
}
if (isIl2Cpp)
{
DynamicMethod il2CppShim = CreateIl2CppShim(replacement, original);
InstallIl2CppPatch(patchInfo, il2CppShim);
PatchTools.RememberObject(original, new PotatoTuple {
First = replacement, Second = il2CppShim
});
}
else
{
var errorString = Memory.DetourMethod(original, replacement);
if (errorString != null)
{
throw new FormatException("Method " + original.FullDescription() + " cannot be patched. Reason: " + errorString);
}
PatchTools.RememberObject(original, replacement); // no gc for new value + release old value to gc
}
return(replacement);
}
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 Type Il2CppTypeForPatchType(Type type) {
if (type.IsByRef) {
Type element = type.GetElementType();
if (element == typeof(string) || UnhollowerSupport.IsGeneratedAssemblyType(element)) {
return typeof(IntPtr*);
} else {
return type;
}
} else if (type == typeof(string) || UnhollowerSupport.IsGeneratedAssemblyType(type)) {
return typeof(IntPtr);
} else {
return type;
}
}
public List <DynamicMethod> Patch()
{
lock (locker)
{
var dynamicMethods = new List <DynamicMethod>();
foreach (var original in originals)
{
if (original == null)
{
throw new NullReferenceException("original");
}
if ((original.DeclaringType.Assembly.GetCustomAttributes(typeof(HarmonyShield), false).Count() > 0) ||
(original.DeclaringType.GetCustomAttributes(typeof(HarmonyShield), false).Count() > 0) ||
(original.GetCustomAttributes(typeof(HarmonyShield), false).Count() > 0))
{
continue;
}
if (MelonDebug.IsEnabled() && UnhollowerSupport.IsGeneratedAssemblyType(original.DeclaringType))
{
WarnIfTargetMethodInlined(original);
}
var individualPrepareResult = RunMethod <HarmonyPrepare, bool>(true, original);
if (individualPrepareResult)
{
var patchInfo = HarmonySharedState.GetPatchInfo(original);
if (patchInfo == null)
{
patchInfo = new PatchInfo();
}
PatchFunctions.AddPrefix(patchInfo, instance.Id, prefix);
PatchFunctions.AddPostfix(patchInfo, instance.Id, postfix);
PatchFunctions.AddTranspiler(patchInfo, instance.Id, transpiler);
dynamicMethods.Add(PatchFunctions.UpdateWrapper(original, patchInfo, instance.Id));
HarmonySharedState.UpdatePatchInfo(original, patchInfo);
RunMethod <HarmonyCleanup>(original);
}
}
return(dynamicMethods);
}
}
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);
}