Compare commits

..

45 Commits

Author SHA1 Message Date
walon 811b4ecf60 [fix] 修复WebGL平台ABI的bug 2023-05-26 18:45:35 +08:00
walon f5afc43625 [version] 发布2.4.2版本 2023-05-19 12:31:09 +08:00
walon f8eee2ba49 [change] 更新package信息 2023-05-13 09:38:10 +08:00
walon 07b52bed05 [version] 发布2.4.1 2023-05-12 22:54:25 +08:00
walon 3139fbefa6 [new] 补充遗漏的 RELEASELOG.md.meta 文件 2023-05-10 11:34:31 +08:00
walon fbeeb3d959 发布v2.4.0版本 2023-05-09 18:46:08 +08:00
walon 1f4e754adb [fix] 修复当struct只包含一个float或double字段时,在arm64上计算桥接函数签名错误的bug 2023-05-06 18:57:47 +08:00
walon f63bbc8a52 [opt] CheckSettings中检查ScriptingBackend及ApiCompatibleLevel,切换为正确的值 2023-05-06 12:28:03 +08:00
walon b17751b8a8 [new] 新增 MsvcStdextWorkaround.cs 解决2020 vs下stdext编译错误的问题 2023-05-04 16:23:07 +08:00
walon 05e721cf02 [fix] BuildOptions.CleanBuildCache从UNITY_2021_2_OR_NEWER开始才有,而不是UNITY_2021_1_OR_NEWER 2023-05-03 17:17:40 +08:00
walon 29646f1294 [change] 替换package.json中focus-creative-games为code-philosophy 2023-05-03 15:50:20 +08:00
walon 3702411ac8 [fix] 修复本地复制libil2cpp却仍然从仓库下载安装的bug 2023-05-03 12:22:16 +08:00
walon d205f00a1b [version] 2.3.0版本 2023-04-30 12:03:28 +08:00
walon 2894701063 [fix] 修复2019版本MonoBleedingEdge的子目录中包含了过长路径的文件导致Installer复制文件出错的问题
[change] StripAOTDllCommand失败时抛出异常而不是打印错误日志
2023-04-30 01:35:25 +08:00
walon 1045538b40 [refactor] 调整Installer接口 2023-04-29 12:41:47 +08:00
walon 8fd9b2ec82 [new] Installer支持从本地目录复制改造后的libil2cpp目录 2023-04-29 12:11:16 +08:00
walon 0ccdd424ab [version] 2.2.0版本,支持 2020.3.47及2021.3.23 2023-04-26 11:09:52 +08:00
walon c083e4ada4 [opt] 优化Resolve Assembly失败时的错误信息 2023-04-23 12:20:56 +08:00
walon 4c6dd1249a [fix] 修复WebGL一些桥接函数ABI计算的bug 2023-04-22 14:05:50 +08:00
walon b8b990bfc1 [fix] 为PatchScriptingAssembliesJsonHook的proxy函数添加无用代码以满足最小代码长度要求 2023-03-31 00:22:48 +08:00
walon 252e6add67 [remove] 删除无用的测试代码文件 BuildPipeline_StripDll_HookTest.cs 2023-03-31 00:21:52 +08:00
walon 6e76b96f97 [version] 升级到2.1.0 2023-03-28 22:35:44 +08:00
walon dd18ecdba5 [version] 升级到2.0.11版本 2023-03-28 16:03:37 +08:00
walon 2ff3e276d2 [revert] 回滚版本"6909c32a0c8fcf11d4b573af890a0232c1525afe [new] 支持 2021 WebGL资源上挂载脚本" 引入的MonoHook的bug 2023-03-28 13:25:53 +08:00
Jonson 1d5f2a953c [fix] 修复MonoHook在2020.3.x系列编辑器compile的时候,有可能发生hook没有及时注入从而导致打iOS包失败
[fix]  较高版本的Unity GetFunctionPointer不再依赖GUISkin.current,反而高版本unity的GUISkin.current这个值不会立即有值,导致在编辑器compile等时候,hook没有及时注入从而导致打iOS包失败

---------

Co-authored-by: liaoqiang <liaoqiang@nibirutech.com>
2023-03-28 13:25:32 +08:00
walon 75cb53cb19 [opt] 优化AOTGenericReferences生成,包含assembly列表及美化后的泛型类型及函数名 2023-03-20 17:30:05 +08:00
walon c84f575a2e [change] 对2019修改data.unity3d文件时不再备份data.unity32.bak 2023-03-16 08:39:47 +08:00
walon 3beb788baa [fix] 修复 StripAOTDllCommand由于缓存原因,有些情况下生成失败的问题。通过添加BuildOptions.CleanBuildCache选项解决。此选项在Unity 2021及更高版本新增。 2023-03-13 12:17:39 +08:00
walon 6909c32a0c [new] 支持 2021 WebGL资源上挂载脚本 2023-03-13 09:55:26 +08:00
walon bbb43c3185 [version] hybridclr仓库版本升到v2.0.3 2023-03-11 22:02:32 +08:00
walon 1159125044 [version] 支持2020.3.45及2021.3.20版本 2023-03-11 12:09:46 +08:00
walon 141ff18a7e [version] 升级hybridclr版本为v2.0.2 2023-03-03 12:01:56 +08:00
walon a9ca9fc613 [change] Installer使用tag而不是commit id,安装时不必拉取整个branch,大幅缩短安装时间
[change] 升级hybridclr和il2cpp_plus版本
2023-02-22 10:43:30 +08:00
walon 15f2f0b83c [opt] 优化AssemblyResolver失败时的错误日志 2023-02-12 11:38:18 +08:00
walon d67a11b384 [fix] 修复WebGL平台未正确处理空struct类型的桥接函数签名的bug 2023-02-09 20:11:15 +08:00
walon ff93f30a69 [new] 添加 Mac M1 silicon 平台的MonoHook native插件 2023-02-08 21:59:24 +08:00
walon 275a3bd01a [remove] 移除HybridCLRSettings的collectAssetReferenceTypes选项 2023-02-07 12:42:16 +08:00
walon b5a7899657 [new] 引入 [MonoHook](https://github.com/Misaka-Mikoto-Tech/MonoHook) 彻底解决获得2021版本iOS平台裁剪后AOT dll的问题,不再需要修改UnityEditor.CoreModule.dll 2023-02-06 20:48:22 +08:00
walon fdba92588a [version] 升级到2.0.0版本 2023-02-06 16:42:18 +08:00
walon bf6ae99dad [change] 直接配置了每个unity大版本对应的hybridclr及il2cpp_plus版本,避免出现安装了不兼容版本的问题 2023-01-26 13:11:38 +08:00
walon dbd8121ee2 [remove] 移除2021.3.6版本的 UnityEditor.CoreModule-* 文件
[remove] 移除去安装时对git是否安装的检查
2023-01-20 12:50:24 +08:00
walon 5a50778821 [fix] 修复 Il2CppDefGeneratorCommand 中生成 PlaceHolder Assembly列表时未包含 preserveHotUpdateAssemblies的bug 2023-01-11 17:41:44 +08:00
walon 6834a17968 [change] 升级版本号到1.1.17 2023-01-10 22:09:39 +08:00
walon ef70a49ae2 [change] Il2CppDefGenerator命令新增将热更新dll列表生成到 Il2CppCompatibleDefs.cpp 2023-01-05 21:38:32 +08:00
walon 83c336a5ce [fix] 修复Installer不同的Unity年度版本仍然读取相同的hybridclr及il2cpp_plus版本号配置,导致切换Unity版本时有可能发生默认显示的版本号错误的问题 2022-12-29 20:41:52 +08:00
70 changed files with 3328 additions and 480 deletions
-5
View File
@@ -1,5 +0,0 @@
# change logs
- 2022.8.30 创建
@@ -1,7 +0,0 @@
fileFormatVersion: 2
guid: f42c0f03663d4c14f8a49912c08a514f
TextScriptImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
@@ -1,7 +0,0 @@
fileFormatVersion: 2
guid: b3b3b1f0cbc038149acb4d23bc6d5bf5
TextScriptImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
+19
View File
@@ -0,0 +1,19 @@
{
"versions": [
{
"unity_version":"2019",
"hybridclr" : { "branch":"v2.3.1"},
"il2cpp_plus": { "branch":"v2019-2.2.0"}
},
{
"unity_version":"2020",
"hybridclr" : { "branch":"v2.3.1"},
"il2cpp_plus": { "branch":"v2020-2.2.1"}
},
{
"unity_version":"2021",
"hybridclr" : { "branch":"v2.3.1"},
"il2cpp_plus": { "branch":"v2021-2.2.1"}
}
]
}
@@ -42,11 +42,11 @@ namespace HybridCLR.Editor.UnityBinFileReader
writer.Write(new EndianBinaryWriter(output));
Debug.Log($"patch file:{dataunity3dFile} size:{output.Length}");
string bakFile = dataunity3dFile + ".bak";
if (!File.Exists(bakFile))
{
File.Copy(dataunity3dFile, bakFile);
}
//string bakFile = dataunity3dFile + ".bak";
//if (!File.Exists(bakFile))
//{
// File.Copy(dataunity3dFile, bakFile);
//}
File.WriteAllBytes(dataunity3dFile, output.ToArray());
}
}
@@ -1,5 +1,5 @@
fileFormatVersion: 2
guid: d104ab5da8136154899a40116dc88731
guid: 13fe0cab0b357464d889de45c8d98850
folderAsset: yes
DefaultImporter:
externalObjects: {}
+320
View File
@@ -0,0 +1,320 @@
using DotNetDetour;
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Linq;
namespace MonoHook
{
public unsafe abstract class CodePatcher
{
public bool isValid { get; protected set; }
protected void* _pTarget, _pReplace, _pProxy;
protected int _jmpCodeSize;
protected byte[] _targetHeaderBackup;
public CodePatcher(IntPtr target, IntPtr replace, IntPtr proxy, int jmpCodeSize)
{
_pTarget = target.ToPointer();
_pReplace = replace.ToPointer();
_pProxy = proxy.ToPointer();
_jmpCodeSize = jmpCodeSize;
}
public void ApplyPatch()
{
BackupHeader();
EnableAddrModifiable();
PatchTargetMethod();
PatchProxyMethod();
FlushICache();
}
public void RemovePatch()
{
if (_targetHeaderBackup == null)
return;
EnableAddrModifiable();
RestoreHeader();
FlushICache();
}
protected void BackupHeader()
{
if (_targetHeaderBackup != null)
return;
uint requireSize = LDasm.SizeofMinNumByte(_pTarget, _jmpCodeSize);
_targetHeaderBackup = new byte[requireSize];
fixed (void* ptr = _targetHeaderBackup)
HookUtils.MemCpy(ptr, _pTarget, _targetHeaderBackup.Length);
}
protected void RestoreHeader()
{
if (_targetHeaderBackup == null)
return;
HookUtils.MemCpy_Jit(_pTarget, _targetHeaderBackup);
}
protected void PatchTargetMethod()
{
byte[] buff = GenJmpCode(_pTarget, _pReplace);
HookUtils.MemCpy_Jit(_pTarget, buff);
}
protected void PatchProxyMethod()
{
if (_pProxy == null)
return;
// copy target's code to proxy
HookUtils.MemCpy_Jit(_pProxy, _targetHeaderBackup);
// jmp to target's new position
long jmpFrom = (long)_pProxy + _targetHeaderBackup.Length;
long jmpTo = (long)_pTarget + _targetHeaderBackup.Length;
byte[] buff = GenJmpCode((void*)jmpFrom, (void*)jmpTo);
HookUtils.MemCpy_Jit((void*)jmpFrom, buff);
}
protected void FlushICache()
{
HookUtils.FlushICache(_pTarget, _targetHeaderBackup.Length);
HookUtils.FlushICache(_pProxy, _targetHeaderBackup.Length * 2);
}
protected abstract byte[] GenJmpCode(void* jmpFrom, void* jmpTo);
#if ENABLE_HOOK_DEBUG
protected string PrintAddrs()
{
if (IntPtr.Size == 4)
return $"target:0x{(uint)_pTarget:x}, replace:0x{(uint)_pReplace:x}, proxy:0x{(uint)_pProxy:x}";
else
return $"target:0x{(ulong)_pTarget:x}, replace:0x{(ulong)_pReplace:x}, proxy:0x{(ulong)_pProxy:x}";
}
#endif
private void EnableAddrModifiable()
{
HookUtils.SetAddrFlagsToRWX(new IntPtr(_pTarget), _targetHeaderBackup.Length);
HookUtils.SetAddrFlagsToRWX(new IntPtr(_pProxy), _targetHeaderBackup.Length + _jmpCodeSize);
}
}
public unsafe class CodePatcher_x86 : CodePatcher
{
protected static readonly byte[] s_jmpCode = new byte[] // 5 bytes
{
0xE9, 0x00, 0x00, 0x00, 0x00, // jmp $val ; $val = $dst - $src - 5
};
public CodePatcher_x86(IntPtr target, IntPtr replace, IntPtr proxy) : base(target, replace, proxy, s_jmpCode.Length) { }
protected override unsafe byte[] GenJmpCode(void* jmpFrom, void* jmpTo)
{
byte[] ret = new byte[s_jmpCode.Length];
int val = (int)jmpTo - (int)jmpFrom - 5;
fixed(void * p = &ret[0])
{
byte* ptr = (byte*)p;
*ptr = 0xE9;
int* pOffset = (int*)(ptr + 1);
*pOffset = val;
}
return ret;
}
}
/// <summary>
/// x64下2G 内的跳转
/// </summary>
public unsafe class CodePatcher_x64_near : CodePatcher_x86 // x64_near pathcer code is same to x86
{
public CodePatcher_x64_near(IntPtr target, IntPtr replace, IntPtr proxy) : base(target, replace, proxy) { }
}
/// <summary>
/// x64下距离超过2G的跳转
/// </summary>
public unsafe class CodePatcher_x64_far : CodePatcher
{
protected static readonly byte[] s_jmpCode = new byte[] // 12 bytes
{
// 由于 rax 会被函数作为返回值修改,并且不会被做为参数使用,因此修改是安全的
0x48, 0xB8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov rax, <jmpTo>
0x50, // push rax
0xC3 // ret
};
//protected static readonly byte[] s_jmpCode2 = new byte[] // 14 bytes
//{
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // <jmpTo>
// 0xFF, 0x25, 0xF2, 0xFF, 0xFF, 0xFF // jmp [rip - 0xe]
//};
public CodePatcher_x64_far(IntPtr target, IntPtr replace, IntPtr proxy) : base(target, replace, proxy, s_jmpCode.Length) { }
protected override unsafe byte[] GenJmpCode(void* jmpFrom, void* jmpTo)
{
byte[] ret = new byte[s_jmpCode.Length];
fixed (void* p = &ret[0])
{
byte* ptr = (byte*)p;
*ptr++ = 0x48;
*ptr++ = 0xB8;
*(long*)ptr = (long)jmpTo;
ptr += 8;
*ptr++ = 0x50;
*ptr++ = 0xC3;
}
return ret;
}
}
public unsafe class CodePatcher_arm32_near : CodePatcher
{
private static readonly byte[] s_jmpCode = new byte[] // 4 bytes
{
0x00, 0x00, 0x00, 0xEA, // B $val ; $val = (($dst - $src) / 4 - 2) & 0x1FFFFFF
};
public CodePatcher_arm32_near(IntPtr target, IntPtr replace, IntPtr proxy) : base(target, replace, proxy, s_jmpCode.Length)
{
if (Math.Abs((long)target - (long)replace) >= ((1 << 25) - 1))
throw new ArgumentException("address offset of target and replace must less than ((1 << 25) - 1)");
#if ENABLE_HOOK_DEBUG
Debug.Log($"CodePatcher_arm32_near: {PrintAddrs()}");
#endif
}
protected override unsafe byte[] GenJmpCode(void* jmpFrom, void* jmpTo)
{
byte[] ret = new byte[s_jmpCode.Length];
int val = ((int)jmpTo - (int)jmpFrom) / 4 - 2;
fixed (void* p = &ret[0])
{
byte* ptr = (byte*)p;
*ptr++ = (byte)val;
*ptr++ = (byte)(val >> 8);
*ptr++ = (byte)(val >> 16);
*ptr++ = 0xEA;
}
return ret;
}
}
public unsafe class CodePatcher_arm32_far : CodePatcher
{
private static readonly byte[] s_jmpCode = new byte[] // 8 bytes
{
0x04, 0xF0, 0x1F, 0xE5, // LDR PC, [PC, #-4]
0x00, 0x00, 0x00, 0x00, // $val
};
public CodePatcher_arm32_far(IntPtr target, IntPtr replace, IntPtr proxy) : base(target, replace, proxy, s_jmpCode.Length)
{
if (Math.Abs((long)target - (long)replace) < ((1 << 25) - 1))
throw new ArgumentException("address offset of target and replace must larger than ((1 << 25) - 1), please use InstructionModifier_arm32_near instead");
#if ENABLE_HOOK_DEBUG
Debug.Log($"CodePatcher_arm32_far: {PrintAddrs()}");
#endif
}
protected override unsafe byte[] GenJmpCode(void* jmpFrom, void* jmpTo)
{
byte[] ret = new byte[s_jmpCode.Length];
fixed (void* p = &ret[0])
{
uint* ptr = (uint*)p;
*ptr++ = 0xE51FF004;
*ptr = (uint)jmpTo;
}
return ret;
}
}
/// <summary>
/// arm64 下 ±128MB 范围内的跳转
/// </summary>
public unsafe class CodePatcher_arm64_near : CodePatcher
{
private static readonly byte[] s_jmpCode = new byte[] // 4 bytes
{
/*
* from 0x14 to 0x17 is B opcode
* offset bits is 26
* https://developer.arm.com/documentation/ddi0596/2021-09/Base-Instructions/B--Branch-
*/
0x00, 0x00, 0x00, 0x14, // B $val ; $val = (($dst - $src)/4) & 7FFFFFF
};
public CodePatcher_arm64_near(IntPtr target, IntPtr replace, IntPtr proxy) : base(target, replace, proxy, s_jmpCode.Length)
{
if (Math.Abs((long)target - (long)replace) >= ((1 << 26) - 1) * 4)
throw new ArgumentException("address offset of target and replace must less than (1 << 26) - 1) * 4");
#if ENABLE_HOOK_DEBUG
Debug.Log($"CodePatcher_arm64: {PrintAddrs()}");
#endif
}
protected override unsafe byte[] GenJmpCode(void* jmpFrom, void* jmpTo)
{
byte[] ret = new byte[s_jmpCode.Length];
int val = (int)((long)jmpTo - (long)jmpFrom) / 4;
fixed (void* p = &ret[0])
{
byte* ptr = (byte*)p;
*ptr++ = (byte)val;
*ptr++ = (byte)(val >> 8);
*ptr++ = (byte)(val >> 16);
byte last = (byte)(val >> 24);
last &= 0b11;
last |= 0x14;
*ptr = last;
}
return ret;
}
}
/// <summary>
/// arm64 远距离跳转
/// </summary>
public unsafe class CodePatcher_arm64_far : CodePatcher
{
private static readonly byte[] s_jmpCode = new byte[] // 20 bytes(字节数过多,太危险了,不建议使用)
{
/*
* ADR: https://developer.arm.com/documentation/ddi0596/2021-09/Base-Instructions/ADR--Form-PC-relative-address-
* BR: https://developer.arm.com/documentation/ddi0596/2021-09/Base-Instructions/BR--Branch-to-Register-
*/
0x6A, 0x00, 0x00, 0x10, // ADR X10, #C
0x4A, 0x01, 0x40, 0xF9, // LDR X10, [X10,#0]
0x40, 0x01, 0x1F, 0xD6, // BR X10
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // $dst
};
public CodePatcher_arm64_far(IntPtr target, IntPtr replace, IntPtr proxy, int jmpCodeSize) : base(target, replace, proxy, jmpCodeSize)
{
}
protected override unsafe byte[] GenJmpCode(void* jmpFrom, void* jmpTo)
{
throw new NotImplementedException();
}
}
}
+11
View File
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 97cc0d26f72fc4148b8370b2252d1585
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
+74
View File
@@ -0,0 +1,74 @@
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using UnityEngine;
using System.Linq;
using System.IO;
#if UNITY_EDITOR
using UnityEditor;
#endif
namespace MonoHook
{
/// <summary>
/// Hook 池,防止重复 Hook
/// </summary>
public static class HookPool
{
private static Dictionary<MethodBase, MethodHook> _hooks = new Dictionary<MethodBase, MethodHook>();
public static void AddHook(MethodBase method, MethodHook hook)
{
MethodHook preHook;
if (_hooks.TryGetValue(method, out preHook))
{
preHook.Uninstall();
_hooks[method] = hook;
}
else
_hooks.Add(method, hook);
}
public static MethodHook GetHook(MethodBase method)
{
if (method == null) return null;
MethodHook hook;
if (_hooks.TryGetValue(method, out hook))
return hook;
return null;
}
public static void RemoveHooker(MethodBase method)
{
if (method == null) return;
_hooks.Remove(method);
}
public static void UninstallAll()
{
var list = _hooks.Values.ToList();
foreach (var hook in list)
hook.Uninstall();
_hooks.Clear();
}
public static void UninstallByTag(string tag)
{
var list = _hooks.Values.ToList();
foreach (var hook in list)
{
if(hook.tag == tag)
hook.Uninstall();
}
}
public static List<MethodHook> GetAllHooks()
{
return _hooks.Values.ToList();
}
}
}
+11
View File
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 6b7421e47f0ae1e4ebb72bf18d1d7d48
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
+272
View File
@@ -0,0 +1,272 @@
#if !(UNITY_STANDALONE_OSX || UNITY_EDITOR_OSX)
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using UnityEngine;
namespace MonoHook
{
public static unsafe class HookUtils
{
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
delegate void DelegateFlushICache(void* code, int size); // delegate * unmanaged[Cdecl] <void, byte, uint> native_flush_cache_fun_ptr; // unsupported at C# 8.0
static DelegateFlushICache flush_icache;
private static readonly long _Pagesize;
static HookUtils()
{
PropertyInfo p_SystemPageSize = typeof(Environment).GetProperty("SystemPageSize");
if (p_SystemPageSize == null)
throw new NotSupportedException("Unsupported runtime");
_Pagesize = (int)p_SystemPageSize.GetValue(null, new object[0]);
SetupFlushICacheFunc();
}
public static void MemCpy(void* pDst, void* pSrc, int len)
{
byte* pDst_ = (byte*)pDst;
byte* pSrc_ = (byte*)pSrc;
for (int i = 0; i < len; i++)
*pDst_++ = *pSrc_++;
}
public static void MemCpy_Jit(void* pDst, byte[] src)
{
fixed (void* p = &src[0])
{
MemCpy(pDst, p, src.Length);
}
}
/// <summary>
/// set flags of address to `read write execute`
/// </summary>
public static void SetAddrFlagsToRWX(IntPtr ptr, int size)
{
if (ptr == IntPtr.Zero)
return;
#if UNITY_STANDALONE_WIN || UNITY_EDITOR_WIN
uint oldProtect;
bool ret = VirtualProtect(ptr, (uint)size, Protection.PAGE_EXECUTE_READWRITE, out oldProtect);
UnityEngine.Debug.Assert(ret);
#else
SetMemPerms(ptr,(ulong)size,MmapProts.PROT_READ | MmapProts.PROT_WRITE | MmapProts.PROT_EXEC);
#endif
}
public static void FlushICache(void* code, int size)
{
if (code == null)
return;
flush_icache?.Invoke(code, size);
#if ENABLE_HOOK_DEBUG
Debug.Log($"flush icache at 0x{(IntPtr.Size == 4 ? (uint)code : (ulong)code):x}, size:{size}");
#endif
}
public static KeyValuePair<long, long> GetPageAlignedAddr(long code, int size)
{
long pagesize = _Pagesize;
long startPage = (code) & ~(pagesize - 1);
long endPage = (code + size + pagesize - 1) & ~(pagesize - 1);
return new KeyValuePair<long, long>(startPage, endPage);
}
const int PRINT_SPLIT = 4;
const int PRINT_COL_SIZE = PRINT_SPLIT * 4;
public static string HexToString(void* ptr, int size, int offset = 0)
{
Func<IntPtr, string> formatAddr = (IntPtr addr__) => IntPtr.Size == 4 ? $"0x{(uint)addr__:x}" : $"0x{(ulong)addr__:x}";
byte* addr = (byte*)ptr;
StringBuilder sb = new StringBuilder(1024);
sb.AppendLine($"addr:{formatAddr(new IntPtr(addr))}");
addr += offset;
size += Math.Abs(offset);
int count = 0;
while (true)
{
sb.Append($"\r\n{formatAddr(new IntPtr(addr + count))}: ");
for (int i = 1; i < PRINT_COL_SIZE + 1; i++)
{
if (count >= size)
goto END;
sb.Append($"{*(addr + count):x2}");
if (i % PRINT_SPLIT == 0)
sb.Append(" ");
count++;
}
}
END:;
return sb.ToString();
}
static void SetupFlushICacheFunc()
{
string processorType = SystemInfo.processorType;
if (processorType.Contains("Intel") || processorType.Contains("AMD"))
return;
if (IntPtr.Size == 4)
{
// never release, so save GCHandle is unnecessary
s_ptr_flush_icache_arm32 = GCHandle.Alloc(s_flush_icache_arm32, GCHandleType.Pinned).AddrOfPinnedObject().ToPointer();
SetAddrFlagsToRWX(new IntPtr(s_ptr_flush_icache_arm32), s_flush_icache_arm32.Length);
flush_icache = Marshal.GetDelegateForFunctionPointer<DelegateFlushICache>(new IntPtr(s_ptr_flush_icache_arm32));
}
else
{
s_ptr_flush_icache_arm64 = GCHandle.Alloc(s_flush_icache_arm64, GCHandleType.Pinned).AddrOfPinnedObject().ToPointer();
SetAddrFlagsToRWX(new IntPtr(s_ptr_flush_icache_arm64), s_flush_icache_arm64.Length);
flush_icache = Marshal.GetDelegateForFunctionPointer<DelegateFlushICache>(new IntPtr(s_ptr_flush_icache_arm64));
}
#if ENABLE_HOOK_DEBUG
Debug.Log($"flush_icache delegate is {((flush_icache != null) ? "not " : "")}null");
#endif
}
static void* s_ptr_flush_icache_arm32, s_ptr_flush_icache_arm64;
private static byte[] s_flush_icache_arm32 = new byte[]
{
// void cdecl mono_arch_flush_icache (guint8 *code, gint size)
0x00, 0x48, 0x2D, 0xE9, // PUSH {R11,LR}
0x0D, 0xB0, 0xA0, 0xE1, // MOV R11, SP
0x08, 0xD0, 0x4D, 0xE2, // SUB SP, SP, #8
0x04, 0x00, 0x8D, 0xE5, // STR R0, [SP,#8+var_4]
0x00, 0x10, 0x8D, 0xE5, // STR R1, [SP,#8+var_8]
0x04, 0x00, 0x9D, 0xE5, // LDR R0, [SP,#8+var_4]
0x04, 0x10, 0x9D, 0xE5, // LDR R1, [SP,#8+var_4]
0x00, 0x20, 0x9D, 0xE5, // LDR R2, [SP,#8+var_8]
0x02, 0x10, 0x81, 0xE0, // ADD R1, R1, R2
0x01, 0x00, 0x00, 0xEB, // BL __clear_cache
0x0B, 0xD0, 0xA0, 0xE1, // MOV SP, R11
0x00, 0x88, 0xBD, 0xE8, // POP {R11,PC}
// __clear_cache ; CODE XREF: j___clear_cache+8↑j
0x80, 0x00, 0x2D, 0xE9, // PUSH { R7 }
0x02, 0x70, 0x00, 0xE3, 0x0F, 0x70, 0x40, 0xE3, // MOV R7, #0xF0002
0x00, 0x20, 0xA0, 0xE3, // MOV R2, #0
0x00, 0x00, 0x00, 0xEF, // SVC 0
0x80, 0x00, 0xBD, 0xE8, // POP {R7}
0x1E, 0xFF, 0x2F, 0xE1, // BX LR
};
private static byte[] s_flush_icache_arm64 = new byte[] // X0: code, W1: size
{
// void cdecl mono_arch_flush_icache (guint8 *code, gint size)
0xFF, 0xC3, 0x00, 0xD1, // SUB SP, SP, #0x30
0xE8, 0x03, 0x7E, 0xB2, // MOV X8, #4
0xE0, 0x17, 0x00, 0xF9, // STR X0, [SP,#0x30+var_8]
0xE1, 0x27, 0x00, 0xB9, // STR W1, [SP,#0x30+var_C]
0xE0, 0x17, 0x40, 0xF9, // LDR X0, [SP,#0x30+var_8]
0xE9, 0x27, 0x80, 0xB9, // LDRSW X9, [SP,#0x30+var_C]
0x09, 0x00, 0x09, 0x8B, // ADD X9, X0, X9
0xE9, 0x0F, 0x00, 0xF9, // STR X9, [SP,#0x30+var_18]
0xE8, 0x07, 0x00, 0xF9, // STR X8, [SP,#0x30+var_28]
0xE8, 0x03, 0x00, 0xF9, // STR X8, [SP,#0x30+var_30]
0xE8, 0x17, 0x40, 0xF9, // LDR X8, [SP,#0x30+var_8]
0x08, 0xF5, 0x7E, 0x92, // AND X8, X8, #0xFFFFFFFFFFFFFFFC
0xE8, 0x0B, 0x00, 0xF9, // STR X8, [SP,#0x30+var_20]
// loc_590 ; CODE XREF: mono_arch_flush_icache(uchar*, int)+58↓j
0xE8, 0x0B, 0x40, 0xF9, // LDR X8, [SP,#0x30+var_20]
0xE9, 0x0F, 0x40, 0xF9, // LDR X9, [SP,#0x30+var_18]
0x1F, 0x01, 0x09, 0xEB, // CMP X8, X9
0xE2, 0x00, 0x00, 0x54, // B.CS loc_5B8
0xE8, 0x0B, 0x40, 0xF9, // LDR X8, [SP,#0x30+var_20]
0x28, 0x7E, 0x0B, 0xD5, // SYS #3, c7, c14, #1, X8
0xE8, 0x0B, 0x40, 0xF9, // LDR X8, [SP,#0x30+var_20]
0x08, 0x11, 0x00, 0x91, // ADD X8, X8, #4
0xE8, 0x0B, 0x00, 0xF9, // STR X8, [SP,#0x30+var_20]
0xF7, 0xFF, 0xFF, 0x17, // B loc_590
// ; ---------------------------------------------------------------------------
// loc_5B8 ; CODE XREF: mono_arch_flush_icache(uchar *, int)+40↑j
0x9F, 0x3B, 0x03, 0xD5, // DSB ISH
0xE8, 0x17, 0x40, 0xF9, // LDR X8, [SP,#0x30+var_8]
0x08, 0xF5, 0x7E, 0x92, // AND X8, X8, #0xFFFFFFFFFFFFFFFC
0xE8, 0x0B, 0x00, 0xF9, // STR X8, [SP,#0x30+var_20]
// loc_5C8 ; CODE XREF: mono_arch_flush_icache(uchar *, int)+90↓j
0xE8, 0x0B, 0x40, 0xF9, // LDR X8, [SP,#0x30+var_20]
0xE9, 0x0F, 0x40, 0xF9, // LDR X9, [SP,#0x30+var_18]
0x1F, 0x01, 0x09, 0xEB, // CMP X8, X9
0xE2, 0x00, 0x00, 0x54, // B.CS loc_5F0
0xE8, 0x0B, 0x40, 0xF9, // LDR X8, [SP,#0x30+var_20]
0x28, 0x75, 0x0B, 0xD5, // SYS #3, c7, c5, #1, X8
0xE8, 0x0B, 0x40, 0xF9, // LDR X8, [SP,#0x30+var_20]
0x08, 0x11, 0x00, 0x91, // ADD X8, X8, #4
0xE8, 0x0B, 0x00, 0xF9, // STR X8, [SP,#0x30+var_20]
0xF7, 0xFF, 0xFF, 0x17, // B loc_5C8
// ; ---------------------------------------------------------------------------
// loc_5F0 ; CODE XREF: mono_arch_flush_icache(uchar *, int)+78↑j
0x9F, 0x3B, 0x03, 0xD5, // DSB ISH
0xDF, 0x3F, 0x03, 0xD5, // ISB
0xFF, 0xC3, 0x00, 0x91, // ADD SP, SP, #0x30 ; '0'
0xC0, 0x03, 0x5F, 0xD6, // RET
};
#if UNITY_STANDALONE_WIN || UNITY_EDITOR_WIN
[Flags]
public enum Protection
{
PAGE_NOACCESS = 0x01,
PAGE_READONLY = 0x02,
PAGE_READWRITE = 0x04,
PAGE_WRITECOPY = 0x08,
PAGE_EXECUTE = 0x10,
PAGE_EXECUTE_READ = 0x20,
PAGE_EXECUTE_READWRITE = 0x40,
PAGE_EXECUTE_WRITECOPY = 0x80,
PAGE_GUARD = 0x100,
PAGE_NOCACHE = 0x200,
PAGE_WRITECOMBINE = 0x400
}
[DllImport("kernel32")]
public static extern bool VirtualProtect(IntPtr lpAddress, uint dwSize, Protection flNewProtect, out uint lpflOldProtect);
#else
[Flags]
public enum MmapProts : int {
PROT_READ = 0x1,
PROT_WRITE = 0x2,
PROT_EXEC = 0x4,
PROT_NONE = 0x0,
PROT_GROWSDOWN = 0x01000000,
PROT_GROWSUP = 0x02000000,
}
[DllImport("libc", SetLastError = true, CallingConvention = CallingConvention.Cdecl)]
private static extern int mprotect(IntPtr start, IntPtr len, MmapProts prot);
public static unsafe void SetMemPerms(IntPtr start, ulong len, MmapProts prot) {
var requiredAddr = GetPageAlignedAddr(start.ToInt64(), (int)len);
long startPage = requiredAddr.Key;
long endPage = requiredAddr.Value;
if (mprotect((IntPtr) startPage, (IntPtr) (endPage - startPage), prot) != 0)
throw new Exception($"mprotect with prot:{prot} fail!");
}
#endif
}
}
#endif
+11
View File
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: e84139b42a6164e4c93ce4df1be6dcfb
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
+102
View File
@@ -0,0 +1,102 @@
#if (UNITY_STANDALONE_OSX || UNITY_EDITOR_OSX)
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using UnityEngine;
namespace MonoHook
{
public static unsafe class HookUtils
{
static bool jit_write_protect_supported;
private static readonly long _Pagesize;
static HookUtils()
{
jit_write_protect_supported = pthread_jit_write_protect_supported_np() != 0;
PropertyInfo p_SystemPageSize = typeof(Environment).GetProperty("SystemPageSize");
if (p_SystemPageSize == null)
throw new NotSupportedException("Unsupported runtime");
_Pagesize = (int)p_SystemPageSize.GetValue(null, new object[0]);
}
public static void MemCpy(void* pDst, void* pSrc, int len)
{
byte* pDst_ = (byte*)pDst;
byte* pSrc_ = (byte*)pSrc;
for (int i = 0; i < len; i++)
*pDst_++ = *pSrc_++;
}
public static void MemCpy_Jit(void* pDst, byte[] src)
{
fixed(void * p = &src[0])
{
memcpy_jit(new IntPtr(pDst), new IntPtr(p), src.Length);
}
}
/// <summary>
/// set flags of address to `read write execute`
/// </summary>
public static void SetAddrFlagsToRWX(IntPtr ptr, int size) { }
public static void FlushICache(void* code, int size) { }
public static KeyValuePair<long, long> GetPageAlignedAddr(long code, int size)
{
long pagesize = _Pagesize;
long startPage = (code) & ~(pagesize - 1);
long endPage = (code + size + pagesize - 1) & ~(pagesize - 1);
return new KeyValuePair<long, long>(startPage, endPage);
}
const int PRINT_SPLIT = 4;
const int PRINT_COL_SIZE = PRINT_SPLIT * 4;
public static string HexToString(void* ptr, int size, int offset = 0)
{
Func<IntPtr, string> formatAddr = (IntPtr addr__) => IntPtr.Size == 4 ? $"0x{(uint)addr__:x}" : $"0x{(ulong)addr__:x}";
byte* addr = (byte*)ptr;
StringBuilder sb = new StringBuilder(1024);
sb.AppendLine($"addr:{formatAddr(new IntPtr(addr))}");
addr += offset;
size += Math.Abs(offset);
int count = 0;
while (true)
{
sb.Append($"\r\n{formatAddr(new IntPtr(addr + count))}: ");
for (int i = 1; i < PRINT_COL_SIZE + 1; i++)
{
if (count >= size)
goto END;
sb.Append($"{*(addr + count):x2}");
if (i % PRINT_SPLIT == 0)
sb.Append(" ");
count++;
}
}
END:;
return sb.ToString();
}
[DllImport("pthread", SetLastError = true, CallingConvention = CallingConvention.Cdecl)]
private static extern int pthread_jit_write_protect_supported_np();
[DllImport("libMonoHookUtils_OSX", SetLastError = true, CallingConvention = CallingConvention.Cdecl)]
private static extern IntPtr memcpy_jit(IntPtr dst, IntPtr src, int len);
}
}
#endif
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: efda6e010e5c6594081c4a62861d469f
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -1,5 +1,5 @@
fileFormatVersion: 2
guid: 8f2a6638b09b52f4c9dc8906d090b710
guid: d796fc01daee1964586621890988a5ae
folderAsset: yes
DefaultImporter:
externalObjects: {}
@@ -0,0 +1,67 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using UnityEngine;
using UnityEditor;
using System.Runtime.CompilerServices;
using MonoHook;
using HybridCLR.Editor.BuildProcessors;
using System.IO;
namespace HybridCLR.MonoHook
{
#if UNITY_2021_1_OR_NEWER && UNITY_IOS
[InitializeOnLoad]
public class CopyStrippedAOTAssembliesHook
{
private static MethodHook _hook;
static CopyStrippedAOTAssembliesHook()
{
if (_hook == null)
{
Type type = typeof(UnityEditor.EditorApplication).Assembly.GetType("UnityEditorInternal.AssemblyStripper");
MethodInfo miTarget = type.GetMethod("StripAssembliesTo", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
MethodInfo miReplacement = new StripAssembliesDel(OverrideStripAssembliesTo).Method;
MethodInfo miProxy = new StripAssembliesDel(StripAssembliesToProxy).Method;
_hook = new MethodHook(miTarget, miReplacement, miProxy);
_hook.Install();
}
}
private delegate bool StripAssembliesDel(string outputFolder, out string output, out string error, IEnumerable<string> linkXmlFiles, object runInformation);
private static bool OverrideStripAssembliesTo(string outputFolder, out string output, out string error, IEnumerable<string> linkXmlFiles, object runInformation)
{
bool result = StripAssembliesToProxy(outputFolder, out output, out error, linkXmlFiles, runInformation);
if (!result)
{
return false;
}
UnityEngine.Debug.Log($"== StripAssembliesTo outputDir:{outputFolder}");
string outputStrippedDir = HybridCLR.Editor.SettingsUtil.GetAssembliesPostIl2CppStripDir(EditorUserBuildSettings.activeBuildTarget);
Directory.CreateDirectory(outputStrippedDir);
foreach (var aotDll in Directory.GetFiles(outputFolder, "*.dll"))
{
string dstFile = $"{outputStrippedDir}/{Path.GetFileName(aotDll)}";
Debug.Log($"[RunAssemblyStripper] copy aot dll {aotDll} -> {dstFile}");
File.Copy(aotDll, dstFile, true);
}
return result;
}
[MethodImpl(MethodImplOptions.NoOptimization)]
private static bool StripAssembliesToProxy(string outputFolder, out string output, out string error, IEnumerable<string> linkXmlFiles, object runInformation)
{
Debug.LogError("== StripAssembliesToProxy ==");
output = "";
error = "";
return true;
}
}
#endif
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: cf42c4f20b8a1b94baa04a1a5c6b8beb
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,57 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using UnityEngine;
using UnityEditor;
using System.Runtime.CompilerServices;
using MonoHook;
using HybridCLR.Editor.BuildProcessors;
using System.IO;
namespace HybridCLR.MonoHook
{
#if UNITY_2021_1_OR_NEWER && UNITY_WEBGL
[InitializeOnLoad]
public class PatchScriptingAssembliesJsonHook
{
private static MethodHook _hook;
static PatchScriptingAssembliesJsonHook()
{
if (_hook == null)
{
Type type = typeof(UnityEditor.EditorApplication);
MethodInfo miTarget = type.GetMethod("BuildMainWindowTitle", BindingFlags.Static | BindingFlags.NonPublic);
MethodInfo miReplacement = new Func<string>(BuildMainWindowTitle).Method;
MethodInfo miProxy = new Func<string>(BuildMainWindowTitleProxy).Method;
_hook = new MethodHook(miTarget, miReplacement, miProxy);
_hook.Install();
}
}
private static string BuildMainWindowTitle()
{
string tempJsonPath = $"{Application.dataPath}/../Library/PlayerDataCache/WebGL/Data/ScriptingAssemblies.json";
if (File.Exists(tempJsonPath))
{
var patcher = new PatchScriptingAssemblyList();
patcher.PathScriptingAssembilesFile(Path.GetDirectoryName(tempJsonPath));
}
string newTitle = BuildMainWindowTitleProxy();
return newTitle;
}
[MethodImpl(MethodImplOptions.NoOptimization)]
private static string BuildMainWindowTitleProxy()
{
// 为满足MonoHook要求的最小代码长度而特地加入的无用填充代码,
UnityEngine.Debug.Log(12345.ToString());
return string.Empty;
}
}
#endif
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: cc89a9041ab48ac41975fbd1e00b9b98
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
+903
View File
@@ -0,0 +1,903 @@
using System;
using System.Runtime.InteropServices;
namespace DotNetDetour
{
/// <summary>
/// 用于计算汇编指令长度,使用的是BlackBone的LDasm.c中的算法,我把他翻译成C#了
/// </summary>
public unsafe class LDasm
{
const int F_INVALID = 0x01;
const int F_PREFIX = 0x02;
const int F_REX = 0x04;
const int F_MODRM = 0x08;
const int F_SIB = 0x10;
const int F_DISP = 0x20;
const int F_IMM = 0x40;
const int F_RELATIVE = 0x80;
const int OP_NONE = 0x00;
const int OP_INVALID = 0x80;
const int OP_DATA_I8 = 0x01;
const int OP_DATA_I16 = 0x02;
const int OP_DATA_I16_I32 = 0x04;
const int OP_DATA_I16_I32_I64 = 0x08;
const int OP_EXTENDED = 0x10;
const int OP_RELATIVE = 0x20;
const int OP_MODRM = 0x40;
const int OP_PREFIX = 0x80;
struct ldasm_data
{
public byte flags;
public byte rex;
public byte modrm;
public byte sib;
public byte opcd_offset;
public byte opcd_size;
public byte disp_offset;
public byte disp_size;
public byte imm_offset;
public byte imm_size;
}
static byte[] flags_table =
{
/* 00 */ OP_MODRM,
/* 01 */ OP_MODRM,
/* 02 */ OP_MODRM,
/* 03 */ OP_MODRM,
/* 04 */ OP_DATA_I8,
/* 05 */ OP_DATA_I16_I32,
/* 06 */ OP_NONE,
/* 07 */ OP_NONE,
/* 08 */ OP_MODRM,
/* 09 */ OP_MODRM,
/* 0A */ OP_MODRM,
/* 0B */ OP_MODRM,
/* 0C */ OP_DATA_I8,
/* 0D */ OP_DATA_I16_I32,
/* 0E */ OP_NONE,
/* 0F */ OP_NONE,
/* 10 */ OP_MODRM,
/* 11 */ OP_MODRM,
/* 12 */ OP_MODRM,
/* 13 */ OP_MODRM,
/* 14 */ OP_DATA_I8,
/* 15 */ OP_DATA_I16_I32,
/* 16 */ OP_NONE,
/* 17 */ OP_NONE,
/* 18 */ OP_MODRM,
/* 19 */ OP_MODRM,
/* 1A */ OP_MODRM,
/* 1B */ OP_MODRM,
/* 1C */ OP_DATA_I8,
/* 1D */ OP_DATA_I16_I32,
/* 1E */ OP_NONE,
/* 1F */ OP_NONE,
/* 20 */ OP_MODRM,
/* 21 */ OP_MODRM,
/* 22 */ OP_MODRM,
/* 23 */ OP_MODRM,
/* 24 */ OP_DATA_I8,
/* 25 */ OP_DATA_I16_I32,
/* 26 */ OP_PREFIX,
/* 27 */ OP_NONE,
/* 28 */ OP_MODRM,
/* 29 */ OP_MODRM,
/* 2A */ OP_MODRM,
/* 2B */ OP_MODRM,
/* 2C */ OP_DATA_I8,
/* 2D */ OP_DATA_I16_I32,
/* 2E */ OP_PREFIX,
/* 2F */ OP_NONE,
/* 30 */ OP_MODRM,
/* 31 */ OP_MODRM,
/* 32 */ OP_MODRM,
/* 33 */ OP_MODRM,
/* 34 */ OP_DATA_I8,
/* 35 */ OP_DATA_I16_I32,
/* 36 */ OP_PREFIX,
/* 37 */ OP_NONE,
/* 38 */ OP_MODRM,
/* 39 */ OP_MODRM,
/* 3A */ OP_MODRM,
/* 3B */ OP_MODRM,
/* 3C */ OP_DATA_I8,
/* 3D */ OP_DATA_I16_I32,
/* 3E */ OP_PREFIX,
/* 3F */ OP_NONE,
/* 40 */ OP_NONE,
/* 41 */ OP_NONE,
/* 42 */ OP_NONE,
/* 43 */ OP_NONE,
/* 44 */ OP_NONE,
/* 45 */ OP_NONE,
/* 46 */ OP_NONE,
/* 47 */ OP_NONE,
/* 48 */ OP_NONE,
/* 49 */ OP_NONE,
/* 4A */ OP_NONE,
/* 4B */ OP_NONE,
/* 4C */ OP_NONE,
/* 4D */ OP_NONE,
/* 4E */ OP_NONE,
/* 4F */ OP_NONE,
/* 50 */ OP_NONE,
/* 51 */ OP_NONE,
/* 52 */ OP_NONE,
/* 53 */ OP_NONE,
/* 54 */ OP_NONE,
/* 55 */ OP_NONE,
/* 56 */ OP_NONE,
/* 57 */ OP_NONE,
/* 58 */ OP_NONE,
/* 59 */ OP_NONE,
/* 5A */ OP_NONE,
/* 5B */ OP_NONE,
/* 5C */ OP_NONE,
/* 5D */ OP_NONE,
/* 5E */ OP_NONE,
/* 5F */ OP_NONE,
/* 60 */ OP_NONE,
/* 61 */ OP_NONE,
/* 62 */ OP_MODRM,
/* 63 */ OP_MODRM,
/* 64 */ OP_PREFIX,
/* 65 */ OP_PREFIX,
/* 66 */ OP_PREFIX,
/* 67 */ OP_PREFIX,
/* 68 */ OP_DATA_I16_I32,
/* 69 */ OP_MODRM | OP_DATA_I16_I32,
/* 6A */ OP_DATA_I8,
/* 6B */ OP_MODRM | OP_DATA_I8,
/* 6C */ OP_NONE,
/* 6D */ OP_NONE,
/* 6E */ OP_NONE,
/* 6F */ OP_NONE,
/* 70 */ OP_RELATIVE | OP_DATA_I8,
/* 71 */ OP_RELATIVE | OP_DATA_I8,
/* 72 */ OP_RELATIVE | OP_DATA_I8,
/* 73 */ OP_RELATIVE | OP_DATA_I8,
/* 74 */ OP_RELATIVE | OP_DATA_I8,
/* 75 */ OP_RELATIVE | OP_DATA_I8,
/* 76 */ OP_RELATIVE | OP_DATA_I8,
/* 77 */ OP_RELATIVE | OP_DATA_I8,
/* 78 */ OP_RELATIVE | OP_DATA_I8,
/* 79 */ OP_RELATIVE | OP_DATA_I8,
/* 7A */ OP_RELATIVE | OP_DATA_I8,
/* 7B */ OP_RELATIVE | OP_DATA_I8,
/* 7C */ OP_RELATIVE | OP_DATA_I8,
/* 7D */ OP_RELATIVE | OP_DATA_I8,
/* 7E */ OP_RELATIVE | OP_DATA_I8,
/* 7F */ OP_RELATIVE | OP_DATA_I8,
/* 80 */ OP_MODRM | OP_DATA_I8,
/* 81 */ OP_MODRM | OP_DATA_I16_I32,
/* 82 */ OP_MODRM | OP_DATA_I8,
/* 83 */ OP_MODRM | OP_DATA_I8,
/* 84 */ OP_MODRM,
/* 85 */ OP_MODRM,
/* 86 */ OP_MODRM,
/* 87 */ OP_MODRM,
/* 88 */ OP_MODRM,
/* 89 */ OP_MODRM,
/* 8A */ OP_MODRM,
/* 8B */ OP_MODRM,
/* 8C */ OP_MODRM,
/* 8D */ OP_MODRM,
/* 8E */ OP_MODRM,
/* 8F */ OP_MODRM,
/* 90 */ OP_NONE,
/* 91 */ OP_NONE,
/* 92 */ OP_NONE,
/* 93 */ OP_NONE,
/* 94 */ OP_NONE,
/* 95 */ OP_NONE,
/* 96 */ OP_NONE,
/* 97 */ OP_NONE,
/* 98 */ OP_NONE,
/* 99 */ OP_NONE,
/* 9A */ OP_DATA_I16 | OP_DATA_I16_I32,
/* 9B */ OP_NONE,
/* 9C */ OP_NONE,
/* 9D */ OP_NONE,
/* 9E */ OP_NONE,
/* 9F */ OP_NONE,
/* A0 */ OP_DATA_I8,
/* A1 */ OP_DATA_I16_I32_I64,
/* A2 */ OP_DATA_I8,
/* A3 */ OP_DATA_I16_I32_I64,
/* A4 */ OP_NONE,
/* A5 */ OP_NONE,
/* A6 */ OP_NONE,
/* A7 */ OP_NONE,
/* A8 */ OP_DATA_I8,
/* A9 */ OP_DATA_I16_I32,
/* AA */ OP_NONE,
/* AB */ OP_NONE,
/* AC */ OP_NONE,
/* AD */ OP_NONE,
/* AE */ OP_NONE,
/* AF */ OP_NONE,
/* B0 */ OP_DATA_I8,
/* B1 */ OP_DATA_I8,
/* B2 */ OP_DATA_I8,
/* B3 */ OP_DATA_I8,
/* B4 */ OP_DATA_I8,
/* B5 */ OP_DATA_I8,
/* B6 */ OP_DATA_I8,
/* B7 */ OP_DATA_I8,
/* B8 */ OP_DATA_I16_I32_I64,
/* B9 */ OP_DATA_I16_I32_I64,
/* BA */ OP_DATA_I16_I32_I64,
/* BB */ OP_DATA_I16_I32_I64,
/* BC */ OP_DATA_I16_I32_I64,
/* BD */ OP_DATA_I16_I32_I64,
/* BE */ OP_DATA_I16_I32_I64,
/* BF */ OP_DATA_I16_I32_I64,
/* C0 */ OP_MODRM | OP_DATA_I8,
/* C1 */ OP_MODRM | OP_DATA_I8,
/* C2 */ OP_DATA_I16,
/* C3 */ OP_NONE,
/* C4 */ OP_MODRM,
/* C5 */ OP_MODRM,
/* C6 */ OP_MODRM | OP_DATA_I8,
/* C7 */ OP_MODRM | OP_DATA_I16_I32,
/* C8 */ OP_DATA_I8 | OP_DATA_I16,
/* C9 */ OP_NONE,
/* CA */ OP_DATA_I16,
/* CB */ OP_NONE,
/* CC */ OP_NONE,
/* CD */ OP_DATA_I8,
/* CE */ OP_NONE,
/* CF */ OP_NONE,
/* D0 */ OP_MODRM,
/* D1 */ OP_MODRM,
/* D2 */ OP_MODRM,
/* D3 */ OP_MODRM,
/* D4 */ OP_DATA_I8,
/* D5 */ OP_DATA_I8,
/* D6 */ OP_NONE,
/* D7 */ OP_NONE,
/* D8 */ OP_MODRM,
/* D9 */ OP_MODRM,
/* DA */ OP_MODRM,
/* DB */ OP_MODRM,
/* DC */ OP_MODRM,
/* DD */ OP_MODRM,
/* DE */ OP_MODRM,
/* DF */ OP_MODRM,
/* E0 */ OP_RELATIVE | OP_DATA_I8,
/* E1 */ OP_RELATIVE | OP_DATA_I8,
/* E2 */ OP_RELATIVE | OP_DATA_I8,
/* E3 */ OP_RELATIVE | OP_DATA_I8,
/* E4 */ OP_DATA_I8,
/* E5 */ OP_DATA_I8,
/* E6 */ OP_DATA_I8,
/* E7 */ OP_DATA_I8,
/* E8 */ OP_RELATIVE | OP_DATA_I16_I32,
/* E9 */ OP_RELATIVE | OP_DATA_I16_I32,
/* EA */ OP_DATA_I16 | OP_DATA_I16_I32,
/* EB */ OP_RELATIVE | OP_DATA_I8,
/* EC */ OP_NONE,
/* ED */ OP_NONE,
/* EE */ OP_NONE,
/* EF */ OP_NONE,
/* F0 */ OP_PREFIX,
/* F1 */ OP_NONE,
/* F2 */ OP_PREFIX,
/* F3 */ OP_PREFIX,
/* F4 */ OP_NONE,
/* F5 */ OP_NONE,
/* F6 */ OP_MODRM,
/* F7 */ OP_MODRM,
/* F8 */ OP_NONE,
/* F9 */ OP_NONE,
/* FA */ OP_NONE,
/* FB */ OP_NONE,
/* FC */ OP_NONE,
/* FD */ OP_NONE,
/* FE */ OP_MODRM,
/* FF */ OP_MODRM
};
static byte[] flags_table_ex =
{
/* 0F00 */ OP_MODRM,
/* 0F01 */ OP_MODRM,
/* 0F02 */ OP_MODRM,
/* 0F03 */ OP_MODRM,
/* 0F04 */ OP_INVALID,
/* 0F05 */ OP_NONE,
/* 0F06 */ OP_NONE,
/* 0F07 */ OP_NONE,
/* 0F08 */ OP_NONE,
/* 0F09 */ OP_NONE,
/* 0F0A */ OP_INVALID,
/* 0F0B */ OP_NONE,
/* 0F0C */ OP_INVALID,
/* 0F0D */ OP_MODRM,
/* 0F0E */ OP_INVALID,
/* 0F0F */ OP_MODRM | OP_DATA_I8, //3Dnow
/* 0F10 */ OP_MODRM,
/* 0F11 */ OP_MODRM,
/* 0F12 */ OP_MODRM,
/* 0F13 */ OP_MODRM,
/* 0F14 */ OP_MODRM,
/* 0F15 */ OP_MODRM,
/* 0F16 */ OP_MODRM,
/* 0F17 */ OP_MODRM,
/* 0F18 */ OP_MODRM,
/* 0F19 */ OP_INVALID,
/* 0F1A */ OP_INVALID,
/* 0F1B */ OP_INVALID,
/* 0F1C */ OP_INVALID,
/* 0F1D */ OP_INVALID,
/* 0F1E */ OP_INVALID,
/* 0F1F */ OP_NONE,
/* 0F20 */ OP_MODRM,
/* 0F21 */ OP_MODRM,
/* 0F22 */ OP_MODRM,
/* 0F23 */ OP_MODRM,
/* 0F24 */ OP_MODRM | OP_EXTENDED, //SSE5
/* 0F25 */ OP_INVALID,
/* 0F26 */ OP_MODRM,
/* 0F27 */ OP_INVALID,
/* 0F28 */ OP_MODRM,
/* 0F29 */ OP_MODRM,
/* 0F2A */ OP_MODRM,
/* 0F2B */ OP_MODRM,
/* 0F2C */ OP_MODRM,
/* 0F2D */ OP_MODRM,
/* 0F2E */ OP_MODRM,
/* 0F2F */ OP_MODRM,
/* 0F30 */ OP_NONE,
/* 0F31 */ OP_NONE,
/* 0F32 */ OP_NONE,
/* 0F33 */ OP_NONE,
/* 0F34 */ OP_NONE,
/* 0F35 */ OP_NONE,
/* 0F36 */ OP_INVALID,
/* 0F37 */ OP_NONE,
/* 0F38 */ OP_MODRM | OP_EXTENDED,
/* 0F39 */ OP_INVALID,
/* 0F3A */ OP_MODRM | OP_EXTENDED | OP_DATA_I8,
/* 0F3B */ OP_INVALID,
/* 0F3C */ OP_INVALID,
/* 0F3D */ OP_INVALID,
/* 0F3E */ OP_INVALID,
/* 0F3F */ OP_INVALID,
/* 0F40 */ OP_MODRM,
/* 0F41 */ OP_MODRM,
/* 0F42 */ OP_MODRM,
/* 0F43 */ OP_MODRM,
/* 0F44 */ OP_MODRM,
/* 0F45 */ OP_MODRM,
/* 0F46 */ OP_MODRM,
/* 0F47 */ OP_MODRM,
/* 0F48 */ OP_MODRM,
/* 0F49 */ OP_MODRM,
/* 0F4A */ OP_MODRM,
/* 0F4B */ OP_MODRM,
/* 0F4C */ OP_MODRM,
/* 0F4D */ OP_MODRM,
/* 0F4E */ OP_MODRM,
/* 0F4F */ OP_MODRM,
/* 0F50 */ OP_MODRM,
/* 0F51 */ OP_MODRM,
/* 0F52 */ OP_MODRM,
/* 0F53 */ OP_MODRM,
/* 0F54 */ OP_MODRM,
/* 0F55 */ OP_MODRM,
/* 0F56 */ OP_MODRM,
/* 0F57 */ OP_MODRM,
/* 0F58 */ OP_MODRM,
/* 0F59 */ OP_MODRM,
/* 0F5A */ OP_MODRM,
/* 0F5B */ OP_MODRM,
/* 0F5C */ OP_MODRM,
/* 0F5D */ OP_MODRM,
/* 0F5E */ OP_MODRM,
/* 0F5F */ OP_MODRM,
/* 0F60 */ OP_MODRM,
/* 0F61 */ OP_MODRM,
/* 0F62 */ OP_MODRM,
/* 0F63 */ OP_MODRM,
/* 0F64 */ OP_MODRM,
/* 0F65 */ OP_MODRM,
/* 0F66 */ OP_MODRM,
/* 0F67 */ OP_MODRM,
/* 0F68 */ OP_MODRM,
/* 0F69 */ OP_MODRM,
/* 0F6A */ OP_MODRM,
/* 0F6B */ OP_MODRM,
/* 0F6C */ OP_MODRM,
/* 0F6D */ OP_MODRM,
/* 0F6E */ OP_MODRM,
/* 0F6F */ OP_MODRM,
/* 0F70 */ OP_MODRM | OP_DATA_I8,
/* 0F71 */ OP_MODRM | OP_DATA_I8,
/* 0F72 */ OP_MODRM | OP_DATA_I8,
/* 0F73 */ OP_MODRM | OP_DATA_I8,
/* 0F74 */ OP_MODRM,
/* 0F75 */ OP_MODRM,
/* 0F76 */ OP_MODRM,
/* 0F77 */ OP_NONE,
/* 0F78 */ OP_MODRM,
/* 0F79 */ OP_MODRM,
/* 0F7A */ OP_INVALID,
/* 0F7B */ OP_INVALID,
/* 0F7C */ OP_MODRM,
/* 0F7D */ OP_MODRM,
/* 0F7E */ OP_MODRM,
/* 0F7F */ OP_MODRM,
/* 0F80 */ OP_RELATIVE | OP_DATA_I16_I32,
/* 0F81 */ OP_RELATIVE | OP_DATA_I16_I32,
/* 0F82 */ OP_RELATIVE | OP_DATA_I16_I32,
/* 0F83 */ OP_RELATIVE | OP_DATA_I16_I32,
/* 0F84 */ OP_RELATIVE | OP_DATA_I16_I32,
/* 0F85 */ OP_RELATIVE | OP_DATA_I16_I32,
/* 0F86 */ OP_RELATIVE | OP_DATA_I16_I32,
/* 0F87 */ OP_RELATIVE | OP_DATA_I16_I32,
/* 0F88 */ OP_RELATIVE | OP_DATA_I16_I32,
/* 0F89 */ OP_RELATIVE | OP_DATA_I16_I32,
/* 0F8A */ OP_RELATIVE | OP_DATA_I16_I32,
/* 0F8B */ OP_RELATIVE | OP_DATA_I16_I32,
/* 0F8C */ OP_RELATIVE | OP_DATA_I16_I32,
/* 0F8D */ OP_RELATIVE | OP_DATA_I16_I32,
/* 0F8E */ OP_RELATIVE | OP_DATA_I16_I32,
/* 0F8F */ OP_RELATIVE | OP_DATA_I16_I32,
/* 0F90 */ OP_MODRM,
/* 0F91 */ OP_MODRM,
/* 0F92 */ OP_MODRM,
/* 0F93 */ OP_MODRM,
/* 0F94 */ OP_MODRM,
/* 0F95 */ OP_MODRM,
/* 0F96 */ OP_MODRM,
/* 0F97 */ OP_MODRM,
/* 0F98 */ OP_MODRM,
/* 0F99 */ OP_MODRM,
/* 0F9A */ OP_MODRM,
/* 0F9B */ OP_MODRM,
/* 0F9C */ OP_MODRM,
/* 0F9D */ OP_MODRM,
/* 0F9E */ OP_MODRM,
/* 0F9F */ OP_MODRM,
/* 0FA0 */ OP_NONE,
/* 0FA1 */ OP_NONE,
/* 0FA2 */ OP_NONE,
/* 0FA3 */ OP_MODRM,
/* 0FA4 */ OP_MODRM | OP_DATA_I8,
/* 0FA5 */ OP_MODRM,
/* 0FA6 */ OP_INVALID,
/* 0FA7 */ OP_INVALID,
/* 0FA8 */ OP_NONE,
/* 0FA9 */ OP_NONE,
/* 0FAA */ OP_NONE,
/* 0FAB */ OP_MODRM,
/* 0FAC */ OP_MODRM | OP_DATA_I8,
/* 0FAD */ OP_MODRM,
/* 0FAE */ OP_MODRM,
/* 0FAF */ OP_MODRM,
/* 0FB0 */ OP_MODRM,
/* 0FB1 */ OP_MODRM,
/* 0FB2 */ OP_MODRM,
/* 0FB3 */ OP_MODRM,
/* 0FB4 */ OP_MODRM,
/* 0FB5 */ OP_MODRM,
/* 0FB6 */ OP_MODRM,
/* 0FB7 */ OP_MODRM,
/* 0FB8 */ OP_MODRM,
/* 0FB9 */ OP_MODRM,
/* 0FBA */ OP_MODRM | OP_DATA_I8,
/* 0FBB */ OP_MODRM,
/* 0FBC */ OP_MODRM,
/* 0FBD */ OP_MODRM,
/* 0FBE */ OP_MODRM,
/* 0FBF */ OP_MODRM,
/* 0FC0 */ OP_MODRM,
/* 0FC1 */ OP_MODRM,
/* 0FC2 */ OP_MODRM | OP_DATA_I8,
/* 0FC3 */ OP_MODRM,
/* 0FC4 */ OP_MODRM | OP_DATA_I8,
/* 0FC5 */ OP_MODRM | OP_DATA_I8,
/* 0FC6 */ OP_MODRM | OP_DATA_I8,
/* 0FC7 */ OP_MODRM,
/* 0FC8 */ OP_NONE,
/* 0FC9 */ OP_NONE,
/* 0FCA */ OP_NONE,
/* 0FCB */ OP_NONE,
/* 0FCC */ OP_NONE,
/* 0FCD */ OP_NONE,
/* 0FCE */ OP_NONE,
/* 0FCF */ OP_NONE,
/* 0FD0 */ OP_MODRM,
/* 0FD1 */ OP_MODRM,
/* 0FD2 */ OP_MODRM,
/* 0FD3 */ OP_MODRM,
/* 0FD4 */ OP_MODRM,
/* 0FD5 */ OP_MODRM,
/* 0FD6 */ OP_MODRM,
/* 0FD7 */ OP_MODRM,
/* 0FD8 */ OP_MODRM,
/* 0FD9 */ OP_MODRM,
/* 0FDA */ OP_MODRM,
/* 0FDB */ OP_MODRM,
/* 0FDC */ OP_MODRM,
/* 0FDD */ OP_MODRM,
/* 0FDE */ OP_MODRM,
/* 0FDF */ OP_MODRM,
/* 0FE0 */ OP_MODRM,
/* 0FE1 */ OP_MODRM,
/* 0FE2 */ OP_MODRM,
/* 0FE3 */ OP_MODRM,
/* 0FE4 */ OP_MODRM,
/* 0FE5 */ OP_MODRM,
/* 0FE6 */ OP_MODRM,
/* 0FE7 */ OP_MODRM,
/* 0FE8 */ OP_MODRM,
/* 0FE9 */ OP_MODRM,
/* 0FEA */ OP_MODRM,
/* 0FEB */ OP_MODRM,
/* 0FEC */ OP_MODRM,
/* 0FED */ OP_MODRM,
/* 0FEE */ OP_MODRM,
/* 0FEF */ OP_MODRM,
/* 0FF0 */ OP_MODRM,
/* 0FF1 */ OP_MODRM,
/* 0FF2 */ OP_MODRM,
/* 0FF3 */ OP_MODRM,
/* 0FF4 */ OP_MODRM,
/* 0FF5 */ OP_MODRM,
/* 0FF6 */ OP_MODRM,
/* 0FF7 */ OP_MODRM,
/* 0FF8 */ OP_MODRM,
/* 0FF9 */ OP_MODRM,
/* 0FFA */ OP_MODRM,
/* 0FFB */ OP_MODRM,
/* 0FFC */ OP_MODRM,
/* 0FFD */ OP_MODRM,
/* 0FFE */ OP_MODRM,
/* 0FFF */ OP_INVALID,
};
static byte cflags(byte op)
{
return flags_table[op];
}
static byte cflags_ex(byte op)
{
return flags_table_ex[op];
}
/// <summary>
/// 计算大于等于 size 字节的最少指令的长度
/// </summary>
/// <param name="code"></param>
/// <returns></returns>
public static uint SizeofMinNumByte(void* code, int size)
{
if (IsARM())
return (uint)((size + 3) / 4) * 4; // 此为 jit 模式下的长度,不再支持 thumb
uint Length;
byte* pOpcode;
uint Result = 0;
ldasm_data data = new ldasm_data();
bool is64 = IntPtr.Size == 8;
do
{
Length = ldasm(code, data, is64);
pOpcode = (byte*)code + data.opcd_offset;
Result += Length;
if (Result >= size)
break;
if ((Length == 1) && (*pOpcode == 0xCC))
break;
code = (void*)((ulong)code + Length);
} while (Length>0);
return Result;
}
static bool? s_isArm;
public static bool IsARM()
{
if(s_isArm.HasValue)
return s_isArm.Value;
var arch = RuntimeInformation.ProcessArchitecture;
s_isArm = arch == Architecture.Arm || arch == Architecture.Arm64;
return s_isArm.Value;
}
public static bool IsArm32()
{
return IsARM() && IntPtr.Size == 4;
}
public static bool IsArm64()
{
return IsARM() && IntPtr.Size == 8;
}
static bool? s_isiOS;
public static bool IsiOS()
{
if(s_isiOS.HasValue)
return s_isiOS.Value;
s_isiOS = UnityEngine.SystemInfo.operatingSystem.ToLower().Contains("ios");
return s_isiOS.Value;
}
static bool? s_isIL2CPP;
public static bool IsIL2CPP()
{
if (s_isIL2CPP.HasValue)
return s_isIL2CPP.Value;
try
{
byte[] ilBody = typeof(LDasm).GetMethod("IsIL2CPP").GetMethodBody().GetILAsByteArray();
if (ilBody == null || ilBody.Length == 0)
s_isIL2CPP = true;
else
s_isIL2CPP = false;
}
catch
{
s_isIL2CPP = true;
}
return s_isIL2CPP.Value;
}
public static bool IsThumb(IntPtr code)
{
return IsArm32() && ((long)code & 0x1) == 0x1;
}
/// <summary>
/// 计算 thumb 指令长度
/// </summary>
/// <param name="code"></param>
/// <param name="size"></param>
/// <returns></returns>
public static uint CalcARMThumbMinLen(void* code, int size)
{
uint len = 0;
ushort* ins = (ushort*)code;
while (true)
{
if (len >= size)
return len;
if (((*ins >> 13) & 3) == 3)
{
ins += 2;
len += 4;
}
else
{
ins++;
len += 2;
}
}
}
static uint ldasm(void* code, ldasm_data ld, bool is64)
{
byte* p = (byte*)code;
byte s, op, f;
byte rexw, pr_66, pr_67;
s = rexw = pr_66 = pr_67 = 0;
/* dummy check */
if ((int)code==0)
return 0;
/* init output data */
//memset(ld, 0, sizeof(ldasm_data));
/* phase 1: parse prefixies */
while ((cflags(*p) & OP_PREFIX)!=0)
{
if (*p == 0x66)
pr_66 = 1;
if (*p == 0x67)
pr_67 = 1;
p++; s++;
ld.flags |= F_PREFIX;
if (s == 15)
{
ld.flags |= F_INVALID;
return s;
}
}
/* parse REX prefix */
if (is64 && *p >> 4 == 4)
{
ld.rex = *p;
rexw = (byte)((ld.rex >> 3) & 1);
ld.flags |= F_REX;
p++; s++;
}
/* can be only one REX prefix */
if (is64 && *p >> 4 == 4)
{
ld.flags |= F_INVALID;
s++;
return s;
}
/* phase 2: parse opcode */
ld.opcd_offset = (byte)(p - (byte*)code);
ld.opcd_size = 1;
op = *p++; s++;
/* is 2 byte opcode? */
if (op == 0x0F)
{
op = *p++; s++;
ld.opcd_size++;
f = cflags_ex(op);
if ((f & OP_INVALID)!=0)
{
ld.flags |= F_INVALID;
return s;
}
/* for SSE instructions */
if ((f & OP_EXTENDED)!=0)
{
op = *p++; s++;
ld.opcd_size++;
}
}
else {
f = cflags(op);
/* pr_66 = pr_67 for opcodes A0-A3 */
if (op >= 0xA0 && op <= 0xA3)
pr_66 = pr_67;
}
/* phase 3: parse ModR/M, SIB and DISP */
if ((f & OP_MODRM)!=0)
{
byte mod = (byte)(*p >> 6);
byte ro = (byte)((*p & 0x38) >> 3);
byte rm = (byte)(*p & 7);
ld.modrm = *p++; s++;
ld.flags |= F_MODRM;
/* in F6,F7 opcodes immediate data present if R/O == 0 */
if (op == 0xF6 && (ro == 0 || ro == 1))
f |= OP_DATA_I8;
if (op == 0xF7 && (ro == 0 || ro == 1))
f |= OP_DATA_I16_I32_I64;
/* is SIB byte exist? */
if (mod != 3 && rm == 4 && !(!is64 && pr_67!=0))
{
ld.sib = *p++; s++;
ld.flags |= F_SIB;
/* if base == 5 and mod == 0 */
if ((ld.sib & 7) == 5 && mod == 0)
{
ld.disp_size = 4;
}
}
switch (mod)
{
case 0:
if (is64)
{
if (rm == 5)
{
ld.disp_size = 4;
if (is64)
ld.flags |= F_RELATIVE;
}
}
else if (pr_67!=0)
{
if (rm == 6)
ld.disp_size = 2;
}
else {
if (rm == 5)
ld.disp_size = 4;
}
break;
case 1:
ld.disp_size = 1;
break;
case 2:
if (is64)
ld.disp_size = 4;
else if (pr_67!=0)
ld.disp_size = 2;
else
ld.disp_size = 4;
break;
}
if (ld.disp_size>0)
{
ld.disp_offset = (byte)(p - (byte*)code);
p += ld.disp_size;
s += ld.disp_size;
ld.flags |= F_DISP;
}
}
/* phase 4: parse immediate data */
if (rexw!=0 && (f & OP_DATA_I16_I32_I64)!=0)
ld.imm_size = 8;
else if ((f & OP_DATA_I16_I32)!=0 || (f & OP_DATA_I16_I32_I64)!=0)
ld.imm_size = (byte)(4 - (pr_66 << 1));
/* if exist, add OP_DATA_I16 and OP_DATA_I8 size */
ld.imm_size += (byte)(f & 3);
if ((ld.imm_size)!=0)
{
s += ld.imm_size;
ld.imm_offset = (byte)(p - (byte*)code);
ld.flags |= F_IMM;
if ((f & OP_RELATIVE)!=0)
ld.flags |= F_RELATIVE;
}
/* instruction is too long */
if (s > 15)
ld.flags |= F_INVALID;
return s;
}
}
}
+11
View File
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 3c561c9729c367e4fbef63f4ec56f268
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
+381
View File
@@ -0,0 +1,381 @@
/*
Desc: 一个可以运行时 Hook Mono 方法的工具,让你可以无需修改 UnityEditor.dll 等文件就可以重写其函数功能
Author: Misaka Mikoto
Github: https://github.com/Misaka-Mikoto-Tech/MonoHook
*/
using DotNetDetour;
using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.InteropServices;
using Unity.Collections.LowLevel.Unsafe;
#if UNITY_EDITOR
using UnityEditor;
#endif
using UnityEngine;
using System.Runtime.CompilerServices;
/*
>>>>>>> 原始 UnityEditor.LogEntries.Clear 一型(.net 4.x)
0000000000403A00 < | 55 | push rbp |
0000000000403A01 | 48 8B EC | mov rbp,rsp |
0000000000403A04 | 48 81 EC 80 00 00 00 | sub rsp,80 |
0000000000403A0B | 48 89 65 B0 | mov qword ptr ss:[rbp-50],rsp |
0000000000403A0F | 48 89 6D A8 | mov qword ptr ss:[rbp-58],rbp |
0000000000403A13 | 48 89 5D C8 | mov qword ptr ss:[rbp-38],rbx | <<
0000000000403A17 | 48 89 75 D0 | mov qword ptr ss:[rbp-30],rsi |
0000000000403A1B | 48 89 7D D8 | mov qword ptr ss:[rbp-28],rdi |
0000000000403A1F | 4C 89 65 E0 | mov qword ptr ss:[rbp-20],r12 |
0000000000403A23 | 4C 89 6D E8 | mov qword ptr ss:[rbp-18],r13 |
0000000000403A27 | 4C 89 75 F0 | mov qword ptr ss:[rbp-10],r14 |
0000000000403A2B | 4C 89 7D F8 | mov qword ptr ss:[rbp-8],r15 |
0000000000403A2F | 49 BB 00 2D 1E 1A FE 7F 00 00 | mov r11,7FFE1A1E2D00 |
0000000000403A39 | 4C 89 5D B8 | mov qword ptr ss:[rbp-48],r11 |
0000000000403A3D | 49 BB 08 2D 1E 1A FE 7F 00 00 | mov r11,7FFE1A1E2D08 |
>>>>>>> 二型(.net 2.x)
0000000000403E8F | 55 | push rbp |
0000000000403E90 | 48 8B EC | mov rbp,rsp |
0000000000403E93 | 48 83 EC 70 | sub rsp,70 |
0000000000403E97 | 48 89 65 C8 | mov qword ptr ss:[rbp-38],rsp |
0000000000403E9B | 48 89 5D B8 | mov qword ptr ss:[rbp-48],rbx |
0000000000403E9F | 48 89 6D C0 | mov qword ptr ss:[rbp-40],rbp | <<(16)
0000000000403EA3 | 48 89 75 F8 | mov qword ptr ss:[rbp-8],rsi |
0000000000403EA7 | 48 89 7D F0 | mov qword ptr ss:[rbp-10],rdi |
0000000000403EAB | 4C 89 65 D0 | mov qword ptr ss:[rbp-30],r12 |
0000000000403EAF | 4C 89 6D D8 | mov qword ptr ss:[rbp-28],r13 |
0000000000403EB3 | 4C 89 75 E0 | mov qword ptr ss:[rbp-20],r14 |
0000000000403EB7 | 4C 89 7D E8 | mov qword ptr ss:[rbp-18],r15 |
0000000000403EBB | 48 83 EC 20 | sub rsp,20 |
0000000000403EBF | 49 BB 18 3F 15 13 FE 7F 00 00 | mov r11,7FFE13153F18 |
0000000000403EC9 | 41 FF D3 | call r11 |
0000000000403ECC | 48 83 C4 20 | add rsp,20 |
>>>>>>>>> arm64
il2cpp:00000000003DE714 F5 0F 1D F8 STR X21, [SP,#-0x10+var_20]! | << absolute safe
il2cpp:00000000003DE718 F4 4F 01 A9 STP X20, X19, [SP,#0x20+var_10] | << may be safe
il2cpp:00000000003DE71C FD 7B 02 A9 STP X29, X30, [SP,#0x20+var_s0] |
il2cpp:00000000003DE720 FD 83 00 91 ADD X29, SP, #0x20 |
il2cpp:00000000003DE724 B5 30 00 B0 ADRP X21, #_ZZ62GameObject_SetActive_mCF1EEF2A314F3AE | << dangerous: relative instruction, can not be overwritten
il2cpp:00000000003DE728 A2 56 47 F9 LDR method, [X21,#_ZZ62GameObject_SetActive_mCF] ; |
il2cpp:00000000003DE72C F3 03 01 2A MOV W19, W1 |
*/
namespace MonoHook
{
/// <summary>
/// Hook 类,用来 Hook 某个 C# 方法
/// </summary>
public unsafe class MethodHook
{
public string tag;
public bool isHooked { get; private set; }
public bool isPlayModeHook { get; private set; }
public MethodBase targetMethod { get; private set; } // 需要被hook的目标方法
public MethodBase replacementMethod { get; private set; } // 被hook后的替代方法
public MethodBase proxyMethod { get; private set; } // 目标方法的代理方法(可以通过此方法调用被hook后的原方法)
private IntPtr _targetPtr; // 目标方法被 jit 后的地址指针
private IntPtr _replacementPtr;
private IntPtr _proxyPtr;
private CodePatcher _codePatcher;
#if UNITY_EDITOR && !UNITY_2020_3_OR_NEWER
/// <summary>
/// call `MethodInfo.MethodHandle.GetFunctionPointer()`
/// will visit static class `UnityEditor.IMGUI.Controls.TreeViewGUI.Styles` and invoke its static constructor,
/// and init static filed `foldout`, but `GUISKin.current` is null now,
/// so we should wait until `GUISKin.current` has a valid value
/// </summary>
private static FieldInfo s_fi_GUISkin_current;
#endif
static MethodHook()
{
#if UNITY_EDITOR && !UNITY_2020_3_OR_NEWER
s_fi_GUISkin_current = typeof(GUISkin).GetField("current", BindingFlags.Static | BindingFlags.NonPublic);
#endif
}
/// <summary>
/// 创建一个 Hook
/// </summary>
/// <param name="targetMethod">需要替换的目标方法</param>
/// <param name="replacementMethod">准备好的替换方法</param>
/// <param name="proxyMethod">如果还需要调用原始目标方法,可以通过此参数的方法调用,如果不需要可以填 null</param>
public MethodHook(MethodBase targetMethod, MethodBase replacementMethod, MethodBase proxyMethod, string data = "")
{
this.targetMethod = targetMethod;
this.replacementMethod = replacementMethod;
this.proxyMethod = proxyMethod;
this.tag = data;
CheckMethod();
}
public void Install()
{
if (LDasm.IsiOS()) // iOS 不支持修改 code 所在区域 page
return;
if (isHooked)
return;
#if UNITY_EDITOR && !UNITY_2020_3_OR_NEWER
if (s_fi_GUISkin_current.GetValue(null) != null)
DoInstall();
else
EditorApplication.update += OnEditorUpdate;
#else
DoInstall();
#endif
isPlayModeHook = Application.isPlaying;
}
public void Uninstall()
{
if (!isHooked)
return;
_codePatcher.RemovePatch();
isHooked = false;
HookPool.RemoveHooker(targetMethod);
}
#region private
private void DoInstall()
{
if (targetMethod == null || replacementMethod == null)
throw new Exception("none of methods targetMethod or replacementMethod can be null");
HookPool.AddHook(targetMethod, this);
if (_codePatcher == null)
{
if (GetFunctionAddr())
{
#if ENABLE_HOOK_DEBUG
UnityEngine.Debug.Log($"Original [{targetMethod.DeclaringType.Name}.{targetMethod.Name}]: {HookUtils.HexToString(_targetPtr.ToPointer(), 64, -16)}");
UnityEngine.Debug.Log($"Original [{replacementMethod.DeclaringType.Name}.{replacementMethod.Name}]: {HookUtils.HexToString(_replacementPtr.ToPointer(), 64, -16)}");
if(proxyMethod != null)
UnityEngine.Debug.Log($"Original [{proxyMethod.DeclaringType.Name}.{proxyMethod.Name}]: {HookUtils.HexToString(_proxyPtr.ToPointer(), 64, -16)}");
#endif
CreateCodePatcher();
_codePatcher.ApplyPatch();
#if ENABLE_HOOK_DEBUG
UnityEngine.Debug.Log($"New [{targetMethod.DeclaringType.Name}.{targetMethod.Name}]: {HookUtils.HexToString(_targetPtr.ToPointer(), 64, -16)}");
UnityEngine.Debug.Log($"New [{replacementMethod.DeclaringType.Name}.{replacementMethod.Name}]: {HookUtils.HexToString(_replacementPtr.ToPointer(), 64, -16)}");
if(proxyMethod != null)
UnityEngine.Debug.Log($"New [{proxyMethod.DeclaringType.Name}.{proxyMethod.Name}]: {HookUtils.HexToString(_proxyPtr.ToPointer(), 64, -16)}");
#endif
}
}
isHooked = true;
}
private void CheckMethod()
{
if (targetMethod == null || replacementMethod == null)
throw new Exception("MethodHook:targetMethod and replacementMethod and proxyMethod can not be null");
string methodName = $"{targetMethod.DeclaringType.Name}.{targetMethod.Name}";
if (targetMethod.IsAbstract)
throw new Exception($"WRANING: you can not hook abstract method [{methodName}]");
#if UNITY_EDITOR && !UNITY_2020_3_OR_NEWER
int minMethodBodySize = 10;
{
if ((targetMethod.MethodImplementationFlags & MethodImplAttributes.InternalCall) != MethodImplAttributes.InternalCall)
{
int codeSize = targetMethod.GetMethodBody().GetILAsByteArray().Length; // GetMethodBody can not call on il2cpp
if (codeSize < minMethodBodySize)
UnityEngine.Debug.LogWarning($"WRANING: you can not hook method [{methodName}], cause its method body is too short({codeSize}), will random crash on IL2CPP release mode");
}
}
if(proxyMethod != null)
{
methodName = $"{proxyMethod.DeclaringType.Name}.{proxyMethod.Name}";
int codeSize = proxyMethod.GetMethodBody().GetILAsByteArray().Length;
if (codeSize < minMethodBodySize)
UnityEngine.Debug.LogWarning($"WRANING: size of method body[{methodName}] is too short({codeSize}), will random crash on IL2CPP release mode, please fill some dummy code inside");
if ((proxyMethod.MethodImplementationFlags & MethodImplAttributes.NoOptimization) != MethodImplAttributes.NoOptimization)
throw new Exception($"WRANING: method [{methodName}] must has a Attribute `MethodImpl(MethodImplOptions.NoOptimization)` to prevent code call to this optimized by compiler(pass args by shared stack)");
}
#endif
}
private void CreateCodePatcher()
{
long addrOffset = Math.Abs(_targetPtr.ToInt64() - _proxyPtr.ToInt64());
if(_proxyPtr != IntPtr.Zero)
addrOffset = Math.Max(addrOffset, Math.Abs(_targetPtr.ToInt64() - _proxyPtr.ToInt64()));
if (LDasm.IsARM())
{
if (IntPtr.Size == 8)
_codePatcher = new CodePatcher_arm64_near(_targetPtr, _replacementPtr, _proxyPtr);
else if (addrOffset < ((1 << 25) - 1))
_codePatcher = new CodePatcher_arm32_near(_targetPtr, _replacementPtr, _proxyPtr);
else if (addrOffset < ((1 << 27) - 1))
_codePatcher = new CodePatcher_arm32_far(_targetPtr, _replacementPtr, _proxyPtr);
else
throw new Exception("address of target method and replacement method are too far, can not hook");
}
else
{
if (IntPtr.Size == 8)
{
if(addrOffset < 0x7fffffff) // 2G
_codePatcher = new CodePatcher_x64_near(_targetPtr, _replacementPtr, _proxyPtr);
else
_codePatcher = new CodePatcher_x64_far(_targetPtr, _replacementPtr, _proxyPtr);
}
else
_codePatcher = new CodePatcher_x86(_targetPtr, _replacementPtr, _proxyPtr);
}
}
/// <summary>
/// 获取对应函数jit后的native code的地址
/// </summary>
private bool GetFunctionAddr()
{
_targetPtr = GetFunctionAddr(targetMethod);
_replacementPtr = GetFunctionAddr(replacementMethod);
_proxyPtr = GetFunctionAddr(proxyMethod);
if (_targetPtr == IntPtr.Zero || _replacementPtr == IntPtr.Zero)
return false;
if (proxyMethod != null && _proxyPtr == null)
return false;
if(_replacementPtr == _targetPtr)
{
throw new Exception($"the addresses of target method {targetMethod.Name} and replacement method {replacementMethod.Name} can not be same");
}
if (LDasm.IsThumb(_targetPtr) || LDasm.IsThumb(_replacementPtr))
{
throw new Exception("does not support thumb arch");
}
return true;
}
[StructLayout(LayoutKind.Sequential, Pack = 1)] // 好像在 IL2CPP 里无效
private struct __ForCopy
{
public long __dummy;
public MethodBase method;
}
/// <summary>
/// 获取方法指令地址
/// </summary>
/// <param name="method"></param>
/// <returns></returns>
private IntPtr GetFunctionAddr(MethodBase method)
{
if (method == null)
return IntPtr.Zero;
if (!LDasm.IsIL2CPP())
return method.MethodHandle.GetFunctionPointer();
else
{
/*
// System.Reflection.MonoMethod
typedef struct Il2CppReflectionMethod
{
Il2CppObject object;
const MethodInfo *method;
Il2CppString *name;
Il2CppReflectionType *reftype;
} Il2CppReflectionMethod;
typedef Il2CppClass Il2CppVTable;
typedef struct Il2CppObject
{
union
{
Il2CppClass *klass;
Il2CppVTable *vtable;
};
MonitorData *monitor;
} Il2CppObject;
typedef struct MethodInfo
{
Il2CppMethodPointer methodPointer; // this is the pointer to native code of method
InvokerMethod invoker_method;
const char* name;
Il2CppClass *klass;
const Il2CppType *return_type;
const ParameterInfo* parameters;
// ...
}
*/
__ForCopy __forCopy = new __ForCopy() { method = method };
long* ptr = &__forCopy.__dummy;
ptr++; // addr of _forCopy.method
IntPtr methodAddr = IntPtr.Zero;
if (sizeof(IntPtr) == 8)
{
long methodDataAddr = *(long*)ptr;
byte* ptrData = (byte*)methodDataAddr + sizeof(IntPtr) * 2; // offset of Il2CppReflectionMethod::const MethodInfo *method;
long methodPtr = 0;
methodPtr = *(long*)ptrData;
methodAddr = new IntPtr(*(long*)methodPtr); // MethodInfo::Il2CppMethodPointer methodPointer;
}
else
{
int methodDataAddr = *(int*)ptr;
byte* ptrData = (byte*)methodDataAddr + sizeof(IntPtr) * 2; // offset of Il2CppReflectionMethod::const MethodInfo *method;
int methodPtr = 0;
methodPtr = *(int*)ptrData;
methodAddr = new IntPtr(*(int*)methodPtr);
}
return methodAddr;
}
}
#if UNITY_EDITOR && !UNITY_2020_3_OR_NEWER
private void OnEditorUpdate()
{
if (s_fi_GUISkin_current.GetValue(null) != null)
{
try
{
DoInstall();
}
finally
{
EditorApplication.update -= OnEditorUpdate;
}
}
}
#endif
#endregion
}
}
+11
View File
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: bd0b8071cf434d6498160259e3829980
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -1,6 +1,7 @@
fileFormatVersion: 2
guid: 33c064b00b452284f93cd6e89de8a06d
TextScriptImporter:
guid: 16b9dc031f67b4fe5ad79c230f75768c
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
+23
View File
@@ -0,0 +1,23 @@
//
// Utils.cpp
// MonoHookUtils_OSX
//
// Created by Misaka-Mikoto on 2022/8/31.
//
#include <stdio.h>
#include <stdint.h>
#include <pthread.h>
#include <string.h>
#include <libkern/OSCacheControl.h>
extern "C"{
void* memcpy_jit(void* dst, void* src, int32_t size)
{
pthread_jit_write_protect_np(0);
void* ret = memcpy(dst, src, size);
pthread_jit_write_protect_np(1);
sys_icache_invalidate (dst, size);
return ret;
}
}
@@ -0,0 +1,81 @@
fileFormatVersion: 2
guid: 56b28b5583a184c669dcb968d175544c
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 0
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 1
Exclude Editor: 0
Exclude Linux64: 1
Exclude OSXUniversal: 1
Exclude WebGL: 1
Exclude Win: 1
Exclude Win64: 1
Exclude iOS: 1
- first:
Android: Android
second:
enabled: 0
settings:
CPU: ARMv7
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 1
settings:
CPU: AnyCPU
DefaultValueInitialized: true
OS: OSX
- first:
Standalone: Linux64
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: OSXUniversal
second:
enabled: 0
settings:
CPU: ARM64
- first:
Standalone: Win
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win64
second:
enabled: 0
settings:
CPU: None
- first:
iPhone: iOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,4 @@
#!/bin/bash
clang -shared -undefined dynamic_lookup -o libMonoHookUtils_OSX.dylib Utils.cpp
@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: 7b2d5d0a85ef3bf44be6cbe94ed5ed2a
TextScriptImporter:
guid: 69eeb734e262a0a4fbe0887249198f73
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 7adba4475cf0bdc4fa7995c0d748f480
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,81 @@
fileFormatVersion: 2
guid: e092a73910a69894daea44290d7292f6
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 1
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 1
Exclude Editor: 0
Exclude Linux64: 1
Exclude OSXUniversal: 1
Exclude WebGL: 1
Exclude Win: 1
Exclude Win64: 1
Exclude iOS: 1
- first:
Android: Android
second:
enabled: 0
settings:
CPU: ARMv7
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 1
settings:
CPU: ARM64
DefaultValueInitialized: true
OS: OSX
- first:
Standalone: Linux64
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: OSXUniversal
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win
second:
enabled: 0
settings:
CPU: x86
- first:
Standalone: Win64
second:
enabled: 0
settings:
CPU: x86_64
- first:
iPhone: iOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 31f6a810e38e66f4c832b135770a04bb
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,81 @@
fileFormatVersion: 2
guid: 4adb23596911347faa69537b900c9f5e
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 0
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 1
Exclude Editor: 0
Exclude Linux64: 1
Exclude OSXUniversal: 1
Exclude WebGL: 1
Exclude Win: 1
Exclude Win64: 1
Exclude iOS: 1
- first:
Android: Android
second:
enabled: 0
settings:
CPU: ARMv7
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 1
settings:
CPU: x86_64
DefaultValueInitialized: true
OS: OSX
- first:
Standalone: Linux64
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: OSXUniversal
second:
enabled: 0
settings:
CPU: AnyCPU
- first:
Standalone: Win
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win64
second:
enabled: 0
settings:
CPU: None
- first:
iPhone: iOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
userData:
assetBundleName:
assetBundleVariant:
+4
View File
@@ -35,5 +35,9 @@ namespace HybridCLR.Editor.ABI
STRUCTURE_ALIGN2,
STRUCTURE_ALIGN4,
STRUCTURE_ALIGN8,
SPECIAL_STRUCTURE_ALIGN1,
SPECIAL_STRUCTURE_ALIGN2,
SPECIAL_STRUCTURE_ALIGN4,
SPECIAL_STRUCTURE_ALIGN8,
}
}
+94 -2
View File
@@ -19,8 +19,6 @@ namespace HybridCLR.Editor.ABI
{
public override bool IsArch32 => false;
public override bool IsSupportHFA => true;
protected override TypeInfo OptimizeSigType(TypeInfo type, bool returnType)
{
if (!type.IsGeneralValueType)
@@ -42,5 +40,99 @@ namespace HybridCLR.Editor.ABI
}
return TypeInfo.s_ref;
}
private static bool IsNotHFAFastCheck(int typeSize)
{
return typeSize % 4 != 0 || typeSize > 32;
}
private static bool ComputHFATypeInfo0(TypeSig type, HFATypeInfo typeInfo)
{
TypeDef typeDef = type.ToTypeDefOrRef().ResolveTypeDefThrow();
List<TypeSig> klassInst = type.ToGenericInstSig()?.GenericArguments?.ToList();
GenericArgumentContext ctx = klassInst != null ? new GenericArgumentContext(klassInst, null) : null;
var fields = typeDef.Fields;// typeDef.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (FieldDef field in fields)
{
if (field.IsStatic)
{
continue;
}
TypeSig ftype = ctx != null ? MetaUtil.Inflate(field.FieldType, ctx) : field.FieldType;
switch (ftype.ElementType)
{
case ElementType.R4:
case ElementType.R8:
{
if (ftype == typeInfo.Type || typeInfo.Type == null)
{
typeInfo.Type = ftype;
++typeInfo.Count;
}
else
{
return false;
}
break;
}
case ElementType.ValueType:
{
if (!ComputHFATypeInfo0(ftype, typeInfo))
{
return false;
}
break;
}
case ElementType.GenericInst:
{
if (!ftype.IsValueType || !ComputHFATypeInfo0(ftype, typeInfo))
{
return false;
}
break;
}
default: return false;
}
}
return typeInfo.Count <= 4;
}
private static bool ComputHFATypeInfo(TypeSig type, int typeSize, out HFATypeInfo typeInfo)
{
typeInfo = new HFATypeInfo();
if (IsNotHFAFastCheck(typeSize))
{
return false;
}
bool ok = ComputHFATypeInfo0(type, typeInfo);
if (ok && typeInfo.Count >= 1 && typeInfo.Count <= 4)
{
int fieldSize = typeInfo.Type.ElementType == ElementType.R4 ? 4 : 8;
return typeSize == fieldSize * typeInfo.Count;
}
return false;
}
protected override bool TryCreateCustomValueTypeInfo(TypeSig type, int typeSize, int typeAligment, out TypeInfo typeInfo)
{
if (ComputHFATypeInfo(type, typeSize, out HFATypeInfo hfaTypeInfo))
{
bool isFloat = hfaTypeInfo.Type.ElementType == ElementType.R4;
switch (hfaTypeInfo.Count)
{
case 1: typeInfo = isFloat ? TypeInfo.s_r4 : TypeInfo.s_r8; break;
case 2: typeInfo = isFloat ? TypeInfo.s_vf2 : TypeInfo.s_vd2; break;
case 3: typeInfo = isFloat ? TypeInfo.s_vf3 : TypeInfo.s_vd3; break;
case 4: typeInfo = isFloat ? TypeInfo.s_vf4 : TypeInfo.s_vd4; break;
default: throw new NotSupportedException();
}
return true;
}
typeInfo = null;
return false;
}
}
}
+23 -164
View File
@@ -13,10 +13,6 @@ namespace HybridCLR.Editor.ABI
{
public abstract bool IsArch32 { get; }
public virtual bool IsSupportHFA => false;
public virtual bool IsSupportSingletonStruct => false;
public TypeInfo GetNativeIntTypeInfo() => IsArch32 ? TypeInfo.s_i4 : TypeInfo.s_i8;
public ValueTypeSizeAligmentCalculator Calculator => IsArch32 ? ValueTypeSizeAligmentCalculator.Caculator32 : ValueTypeSizeAligmentCalculator.Caculator64;
@@ -24,6 +20,9 @@ namespace HybridCLR.Editor.ABI
private readonly Dictionary<TypeSig, (int, int)> _typeSizeCache = new Dictionary<TypeSig, (int, int)>(TypeEqualityComparer.Instance);
private readonly Dictionary<TypeSig, TypeInfo> _typeInfoCache = new Dictionary<TypeSig, TypeInfo>(TypeEqualityComparer.Instance);
public (int Size, int Aligment) ComputeSizeAndAligment(TypeSig t)
{
if (_typeSizeCache.TryGetValue(t, out var sizeAndAligment))
@@ -36,6 +35,16 @@ namespace HybridCLR.Editor.ABI
}
public TypeInfo CreateTypeInfo(TypeSig type)
{
if (!_typeInfoCache.TryGetValue(type, out var typeInfo))
{
typeInfo = CreateTypeInfo0(type);
_typeInfoCache.Add(type, typeInfo);
}
return new TypeInfo(typeInfo.PorType, typeInfo.Size);
}
TypeInfo CreateTypeInfo0(TypeSig type)
{
type = type.RemovePinnedAndModifiers();
if (type.IsByRef)
@@ -70,7 +79,7 @@ namespace HybridCLR.Editor.ABI
case ElementType.Module:
case ElementType.Var:
case ElementType.MVar:
return GetNativeIntTypeInfo();
return GetNativeIntTypeInfo();
case ElementType.TypedByRef: return CreateValueType(type);
case ElementType.ValueType:
{
@@ -103,152 +112,6 @@ namespace HybridCLR.Editor.ABI
}
}
private static bool IsNotHFAFastCheck(int typeSize)
{
return typeSize != 8 && typeSize != 12 && typeSize != 16 && typeSize != 24 && typeSize != 32;
}
private static bool ComputHFATypeInfo0(TypeSig type, HFATypeInfo typeInfo)
{
TypeDef typeDef = type.ToTypeDefOrRef().ResolveTypeDefThrow();
List<TypeSig> klassInst = type.ToGenericInstSig()?.GenericArguments?.ToList();
GenericArgumentContext ctx = klassInst != null ? new GenericArgumentContext(klassInst, null) : null;
var fields = typeDef.Fields;// typeDef.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (FieldDef field in fields)
{
if (field.IsStatic)
{
continue;
}
TypeSig ftype = ctx != null ? MetaUtil.Inflate(field.FieldType, ctx) : field.FieldType;
switch (ftype.ElementType)
{
case ElementType.R4:
case ElementType.R8:
{
if (ftype == typeInfo.Type || typeInfo.Type == null)
{
typeInfo.Type = ftype;
++typeInfo.Count;
}
else
{
return false;
}
break;
}
case ElementType.ValueType:
{
if (!ComputHFATypeInfo0(ftype, typeInfo))
{
return false;
}
break;
}
case ElementType.GenericInst:
{
if (!ftype.IsValueType || !ComputHFATypeInfo0(ftype, typeInfo))
{
return false;
}
break;
}
default: return false;
}
}
return typeInfo.Count <= 4;
}
private static bool ComputHFATypeInfo(TypeSig type, int typeSize, out HFATypeInfo typeInfo)
{
typeInfo = new HFATypeInfo();
if (IsNotHFAFastCheck(typeSize))
{
return false;
}
bool ok = ComputHFATypeInfo0(type, typeInfo);
if (ok && typeInfo.Count >= 2 && typeInfo.Count <= 4)
{
int fieldSize = typeInfo.Type.ElementType == ElementType.R4 ? 4 : 8;
return typeSize == fieldSize * typeInfo.Count;
}
return false;
}
public static bool TryComputSingletonStruct(TypeSig type, out SingletonStruct result)
{
result = new SingletonStruct();
return TryComputSingletonStruct0(type, result) && result.Type != null;
}
public static bool TryComputSingletonStruct0(TypeSig type, SingletonStruct result)
{
TypeDef typeDef = type.ToTypeDefOrRef().ResolveTypeDefThrow();
if (typeDef.IsEnum)
{
if (result.Type == null)
{
result.Type = typeDef.GetEnumUnderlyingType();
return true;
}
else
{
return false;
}
}
List<TypeSig> klassInst = type.ToGenericInstSig()?.GenericArguments?.ToList();
GenericArgumentContext ctx = klassInst != null ? new GenericArgumentContext(klassInst, null) : null;
var fields = typeDef.Fields;// typeDef.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (FieldDef field in fields)
{
if (field.IsStatic)
{
continue;
}
TypeSig ftype = ctx != null ? MetaUtil.Inflate(field.FieldType, ctx) : field.FieldType;
switch (ftype.ElementType)
{
case ElementType.TypedByRef: return false;
case ElementType.ValueType:
{
if (!TryComputSingletonStruct0(ftype, result))
{
return false;
}
break;
}
case ElementType.GenericInst:
{
if (!ftype.IsValueType)
{
goto default;
}
if (!TryComputSingletonStruct0(ftype, result))
{
return false;
}
break;
}
default:
{
if (result.Type != null)
{
return false;
}
result.Type = ftype;
break;
}
}
}
return true;
}
protected static TypeInfo CreateGeneralValueType(TypeSig type, int size, int aligment)
{
System.Diagnostics.Debug.Assert(size % aligment == 0);
@@ -262,24 +125,20 @@ namespace HybridCLR.Editor.ABI
}
}
protected virtual bool TryCreateCustomValueTypeInfo(TypeSig type, int typeSize, int typeAligment, out TypeInfo typeInfo)
{
typeInfo = null;
return false;
}
protected TypeInfo CreateValueType(TypeSig type)
{
(int typeSize, int typeAligment) = ComputeSizeAndAligment(type);
if (IsSupportHFA && ComputHFATypeInfo(type, typeSize, out HFATypeInfo hfaTypeInfo))
if (TryCreateCustomValueTypeInfo(type, typeSize, typeAligment, out var typeInfo))
{
bool isFloat = hfaTypeInfo.Type.ElementType == ElementType.R4;
switch (hfaTypeInfo.Count)
{
case 2: return isFloat ? TypeInfo.s_vf2 : TypeInfo.s_vd2;
case 3: return isFloat ? TypeInfo.s_vf3 : TypeInfo.s_vd3;
case 4: return isFloat ? TypeInfo.s_vf4 : TypeInfo.s_vd4;
default: throw new NotSupportedException();
}
Debug.Log($"[{GetType().Name}] CustomeValueType:{type} => {typeInfo.CreateSigName()}");
return typeInfo;
}
//else if(IsSupportSingletonStruct && TryComputSingletonStruct(type, out var ssTypeInfo))
//{
// return CreateTypeInfo(ssTypeInfo.Type);
//}
else
{
// 64位下结构体内存对齐规则是一样的
-2
View File
@@ -10,8 +10,6 @@ namespace HybridCLR.Editor.ABI
{
public override bool IsArch32 => true;
public override bool IsSupportHFA => false;
protected override TypeInfo OptimizeSigType(TypeInfo type, bool returnType)
{
if (type.PorType > ParamOrReturnType.STRUCTURE_ALIGN1 && type.PorType <= ParamOrReturnType.STRUCTURE_ALIGN4)
+2 -3
View File
@@ -1,4 +1,5 @@
using System;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
@@ -10,8 +11,6 @@ namespace HybridCLR.Editor.ABI
{
public override bool IsArch32 => false;
public override bool IsSupportHFA => true;
protected override TypeInfo OptimizeSigType(TypeInfo type, bool returnType)
{
if (type.PorType > ParamOrReturnType.STRUCTURE_ALIGN1 && type.PorType <= ParamOrReturnType.STRUCTURE_ALIGN8)
+191 -5
View File
@@ -17,11 +17,6 @@ namespace HybridCLR.Editor.ABI
{
public override bool IsArch32 => true;
public override bool IsSupportHFA => false;
public override bool IsSupportSingletonStruct => true;
protected override TypeInfo OptimizeSigType(TypeInfo type, bool returnType)
{
//if (type.PorType > ParamOrReturnType.STRUCTURE_ALIGN1 && type.PorType <= ParamOrReturnType.STRUCTURE_ALIGN4)
@@ -30,5 +25,196 @@ namespace HybridCLR.Editor.ABI
//}
return type;
}
private static bool IsEmptyOrSpeicalValueType(TypeSig type)
{
TypeDef typeDef = type.ToTypeDefOrRef().ResolveTypeDefThrow();
if (typeDef.IsEnum)
{
return false;
}
var fields = typeDef.Fields;// typeDef.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (fields.Count == 0)
{
return true;
}
if (fields.All(f => f.IsStatic))
{
return true;
}
if (typeDef.IsExplicitLayout && fields.Count(f => !f.IsStatic) > 1)
{
return true;
}
return false;
}
public static bool TryComputSingletonStructTypeInfo(TypeSig type, int typeAligment, int typeSize, out TypeInfo typeInfo)
{
typeInfo = null;
if (typeAligment > 8 || typeSize > 8)
{
return false;
}
var ss = new SingletonStruct();
if (!TryComputSingletonStruct0(type, ss) || ss.Type == null)
{
return false;
}
if (ss.Type.IsByRef)
{
typeInfo = TypeInfo.s_i4;
return true;
}
switch (ss.Type.ElementType)
{
case ElementType.Boolean:
case ElementType.Char:
case ElementType.I1:
case ElementType.U1:
case ElementType.I2:
case ElementType.U2:
case ElementType.I4:
case ElementType.U4:
case ElementType.I:
case ElementType.U:
case ElementType.String:
case ElementType.Ptr:
case ElementType.Class:
case ElementType.Array:
case ElementType.GenericInst:
case ElementType.FnPtr:
case ElementType.Object:
case ElementType.SZArray:
{
if (typeAligment <= 4 && typeSize <= 4)
{
typeInfo = TypeInfo.s_i4;
}
break;
}
case ElementType.I8:
case ElementType.U8:
{
if (typeAligment <= 8 && typeSize <= 8)
{
typeInfo = TypeInfo.s_i8;
}
break;
}
case ElementType.R4:
{
if (typeAligment <= 4 && typeSize <= 4)
{
typeInfo = TypeInfo.s_r4;
}
break;
}
case ElementType.R8:
{
if (typeAligment <= 8 && typeSize <= 8)
{
typeInfo = TypeInfo.s_r8;
}
break;
}
default: return false;
}
return typeInfo != null;
}
public static bool TryComputSingletonStruct(TypeSig type, out SingletonStruct result)
{
result = new SingletonStruct();
return TryComputSingletonStruct0(type, result) && result.Type != null;
}
public static bool TryComputSingletonStruct0(TypeSig type, SingletonStruct result)
{
TypeDef typeDef = type.ToTypeDefOrRef().ResolveTypeDefThrow();
if (typeDef.IsEnum)
{
if (result.Type == null)
{
result.Type = typeDef.GetEnumUnderlyingType();
return true;
}
else
{
return false;
}
}
List<TypeSig> klassInst = type.ToGenericInstSig()?.GenericArguments?.ToList();
GenericArgumentContext ctx = klassInst != null ? new GenericArgumentContext(klassInst, null) : null;
var fields = typeDef.Fields;// typeDef.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (FieldDef field in fields)
{
if (field.IsStatic)
{
continue;
}
TypeSig ftype = ctx != null ? MetaUtil.Inflate(field.FieldType, ctx) : field.FieldType;
switch (ftype.ElementType)
{
case ElementType.TypedByRef: return false;
case ElementType.ValueType:
{
if (!TryComputSingletonStruct0(ftype, result))
{
return false;
}
break;
}
case ElementType.GenericInst:
{
if (!ftype.IsValueType)
{
goto default;
}
if (!TryComputSingletonStruct0(ftype, result))
{
return false;
}
break;
}
default:
{
if (result.Type != null)
{
return false;
}
result.Type = ftype;
break;
}
}
}
return true;
}
protected override bool TryCreateCustomValueTypeInfo(TypeSig type, int typeSize, int typeAligment, out TypeInfo typeInfo)
{
typeInfo = null;
if (IsEmptyOrSpeicalValueType(type))
{
switch (typeAligment)
{
case 1: typeInfo = new TypeInfo(ParamOrReturnType.SPECIAL_STRUCTURE_ALIGN1, typeSize); break;
case 2: typeInfo = new TypeInfo(ParamOrReturnType.SPECIAL_STRUCTURE_ALIGN2, typeSize); break;
case 4: typeInfo = new TypeInfo(ParamOrReturnType.SPECIAL_STRUCTURE_ALIGN4, typeSize); break;
case 8: typeInfo = new TypeInfo(ParamOrReturnType.SPECIAL_STRUCTURE_ALIGN8, typeSize); break;
default: throw new NotSupportedException();
}
return true;
}
if (TryComputSingletonStructTypeInfo(type, typeAligment, typeSize, out typeInfo))
{
return true;
}
return false;
}
}
}
+14 -1
View File
@@ -90,6 +90,10 @@ namespace HybridCLR.Editor.ABI
case ParamOrReturnType.STRUCTURE_ALIGN2: return "A" + Size;
case ParamOrReturnType.STRUCTURE_ALIGN4: return "B" + Size;
case ParamOrReturnType.STRUCTURE_ALIGN8: return "C" + Size;
case ParamOrReturnType.SPECIAL_STRUCTURE_ALIGN1: return "X" + Size;
case ParamOrReturnType.SPECIAL_STRUCTURE_ALIGN2: return "Y" + Size;
case ParamOrReturnType.SPECIAL_STRUCTURE_ALIGN4: return "Z" + Size;
case ParamOrReturnType.SPECIAL_STRUCTURE_ALIGN8: return "W" + Size;
default: throw new NotSupportedException(PorType.ToString());
};
}
@@ -121,6 +125,10 @@ namespace HybridCLR.Editor.ABI
case ParamOrReturnType.STRUCTURE_ALIGN2: return $"ValueTypeSizeAlign2<{Size}>";
case ParamOrReturnType.STRUCTURE_ALIGN4: return $"ValueTypeSizeAlign4<{Size}>";
case ParamOrReturnType.STRUCTURE_ALIGN8: return $"ValueTypeSizeAlign8<{Size}>";
case ParamOrReturnType.SPECIAL_STRUCTURE_ALIGN1: return $"WebGLSpeicalValueType<{Size}>";
case ParamOrReturnType.SPECIAL_STRUCTURE_ALIGN2: return $"WebGLSpeicalValueTypeAlign2<{Size}>";
case ParamOrReturnType.SPECIAL_STRUCTURE_ALIGN4: return $"WebGLSpeicalValueTypeAlign4<{Size}>";
case ParamOrReturnType.SPECIAL_STRUCTURE_ALIGN8: return $"WebGLSpeicalValueTypeAlign8<{Size}>";
default: throw new NotImplementedException(PorType.ToString());
};
}
@@ -141,7 +149,12 @@ namespace HybridCLR.Editor.ABI
case ParamOrReturnType.STRUCTURE_ALIGN1:
case ParamOrReturnType.STRUCTURE_ALIGN2:
case ParamOrReturnType.STRUCTURE_ALIGN4:
case ParamOrReturnType.STRUCTURE_ALIGN8: return (Size + 7) / 8;
case ParamOrReturnType.STRUCTURE_ALIGN8:
case ParamOrReturnType.SPECIAL_STRUCTURE_ALIGN1:
case ParamOrReturnType.SPECIAL_STRUCTURE_ALIGN2:
case ParamOrReturnType.SPECIAL_STRUCTURE_ALIGN4:
case ParamOrReturnType.SPECIAL_STRUCTURE_ALIGN8:
return (Size + 7) / 8;
default:
{
Debug.Assert(PorType < ParamOrReturnType.STRUCT_NOT_PASS_AS_VALUE);
+62 -3
View File
@@ -4,6 +4,7 @@ using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using UnityEngine;
@@ -11,6 +12,52 @@ namespace HybridCLR.Editor.AOT
{
public class GenericReferenceWriter
{
private static readonly Dictionary<Type, string> _typeNameMapping = new Dictionary<Type, string>
{
{typeof(bool), "bool" },
{typeof(byte), "byte" },
{typeof(sbyte), "sbyte" },
{typeof(short), "short" },
{typeof(ushort), "ushort" },
{typeof(int), "int" },
{typeof(uint), "uint" },
{typeof(long), "long" },
{typeof(ulong), "ulong" },
{typeof(float), "float" },
{typeof(double), "double" },
{typeof(object), "object" },
{typeof(string), "string" },
};
private readonly Dictionary<string, string> _typeSimpleNameMapping = new Dictionary<string, string>();
private readonly Regex _systemTypePattern;
private readonly Regex _genericPattern = new Regex(@"`\d+");
public GenericReferenceWriter()
{
foreach (var e in _typeNameMapping)
{
_typeSimpleNameMapping.Add(e.Key.FullName, e.Value);
}
_systemTypePattern = new Regex(string.Join("|", _typeSimpleNameMapping.Keys.Select (k => $@"\b{k}\b")));
}
public string PrettifyTypeSig(string typeSig)
{
string s = _genericPattern.Replace(typeSig, "").Replace('/', '.');
return _systemTypePattern.Replace(s, m => _typeSimpleNameMapping[m.Groups[0].Value]);
}
public string PrettifyMethodSig(string methodSig)
{
string s = PrettifyTypeSig(methodSig).Replace("::", ".");
if (s.Contains(".ctor("))
{
s = "new " + s.Replace(".ctor(", "(");
}
return s;
}
public void Write(List<GenericClass> types, List<GenericMethod> methods, string outputFile)
{
string parentDir = Directory.GetParent(outputFile).FullName;
@@ -20,18 +67,30 @@ namespace HybridCLR.Editor.AOT
codes.Add("public class AOTGenericReferences : UnityEngine.MonoBehaviour");
codes.Add("{");
codes.Add("");
codes.Add("\t// {{ AOT assemblies");
List<dnlib.DotNet.ModuleDef> modules = new HashSet<dnlib.DotNet.ModuleDef>(
types.Select(t => t.Type.Module).Concat(methods.Select(m => m.Method.Module))).ToList();
modules.Sort((a, b) => a.Name.CompareTo(b.Name));
foreach (dnlib.DotNet.ModuleDef module in modules)
{
codes.Add($"\t// {module.Name}");
}
codes.Add("\t// }}");
codes.Add("");
codes.Add("\t// {{ constraint implement type");
codes.Add("\t// }} ");
codes.Add("");
codes.Add("\t// {{ AOT generic type");
codes.Add("\t// {{ AOT generic types");
types.Sort((a, b) => a.Type.FullName.CompareTo(b.Type.FullName));
foreach(var type in types)
{
codes.Add($"\t//{type.ToTypeSig()}");
codes.Add($"\t// {PrettifyTypeSig(type.ToTypeSig().ToString())}");
}
codes.Add("\t// }}");
@@ -51,7 +110,7 @@ namespace HybridCLR.Editor.AOT
});
foreach(var method in methods)
{
codes.Add($"\t\t// {method.ToMethodSpec()}");
codes.Add($"\t\t// {PrettifyMethodSig(method.ToMethodSpec().ToString())}");
}
codes.Add("\t}");
+25 -2
View File
@@ -3,6 +3,7 @@ using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UnityEditor;
using UnityEditor.Build;
using UnityEditor.Build.Reporting;
using UnityEngine;
@@ -40,10 +41,32 @@ namespace HybridCLR.Editor.BuildProcessors
{
return;
}
if (UnityEditor.PlayerSettings.gcIncremental)
if (PlayerSettings.gcIncremental)
{
Debug.LogError($"[CheckSettings] HybridCLR不支持增量式GC,已经自动将该选项关闭");
UnityEditor.PlayerSettings.gcIncremental = false;
PlayerSettings.gcIncremental = false;
}
BuildTargetGroup buildTargetGroup = EditorUserBuildSettings.selectedBuildTargetGroup;
ScriptingImplementation curScriptingImplementation = PlayerSettings.GetScriptingBackend(buildTargetGroup);
ScriptingImplementation targetScriptingImplementation = ScriptingImplementation.IL2CPP;
if (curScriptingImplementation != targetScriptingImplementation)
{
Debug.LogError($"[CheckSettings] 当前ScriptingBackend是:{curScriptingImplementation},已经自动切换为:{targetScriptingImplementation}");
PlayerSettings.SetScriptingBackend(buildTargetGroup, targetScriptingImplementation);
}
ApiCompatibilityLevel curApiCompatibilityLevel = PlayerSettings.GetApiCompatibilityLevel(buildTargetGroup);
#if UNITY_2021_1_OR_NEWER
ApiCompatibilityLevel targetApiCompatibilityLevel = ApiCompatibilityLevel.NET_Unity_4_8;
#else
ApiCompatibilityLevel targetApiCompatibilityLevel = ApiCompatibilityLevel.NET_4_6;
#endif
if (curApiCompatibilityLevel != targetApiCompatibilityLevel)
{
Debug.LogError($"[CheckSettings] 当前ApiCompatibilityLevel是:{curApiCompatibilityLevel},已经自动切换为 {targetApiCompatibilityLevel}。由于下一次打包才生效,主动打断本次打包。");
PlayerSettings.SetApiCompatibilityLevel(buildTargetGroup, ApiCompatibilityLevel.NET_4_6);
throw new BuildFailedException("ApiCompatibilityLevel error");
}
var installer = new Installer.InstallerController();
@@ -24,8 +24,8 @@ namespace HybridCLR.Editor.BuildProcessors
Debug.Log($"[FilterHotFixAssemblies] disabled");
return assemblies;
}
List<string> allHotUpdateDllNames = SettingsUtil.HotUpdateAssemblyNames;
List<string> allHotupdateDllFiles = SettingsUtil.HotUpdateAssemblyFiles;
List<string> allHotUpdateDllNames = SettingsUtil.HotUpdateAssemblyNamesExcludePreserved;
List<string> allHotupdateDllFiles = SettingsUtil.HotUpdateAssemblyFilesExcludePreserved;
// 检查是否重复填写
var hotUpdateDllSet = new HashSet<string>();
@@ -0,0 +1,28 @@
#if UNITY_EDITOR
using System;
using UnityEditor.Build;
using UnityEditor.Build.Reporting;
public class MsvcStdextWorkaround : IPreprocessBuildWithReport
{
const string kWorkaroundFlag = "/D_SILENCE_STDEXT_HASH_DEPRECATION_WARNINGS";
public int callbackOrder => 0;
public void OnPreprocessBuild(BuildReport report)
{
var clEnv = Environment.GetEnvironmentVariable("_CL_");
if (string.IsNullOrEmpty(clEnv))
{
Environment.SetEnvironmentVariable("_CL_", kWorkaroundFlag);
}
else if (!clEnv.Contains(kWorkaroundFlag))
{
clEnv += " " + kWorkaroundFlag;
Environment.SetEnvironmentVariable("_CL_", clEnv);
}
}
}
#endif // UNITY_EDITOR
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 8bff6cadf0b8db54b87ba51b24d080f6
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -52,7 +52,7 @@ namespace HybridCLR.Editor.BuildProcessors
#endif
}
private void PathScriptingAssembilesFile(string path)
public void PathScriptingAssembilesFile(string path)
{
if (!SettingsUtil.Enable)
{
@@ -92,7 +92,7 @@ namespace HybridCLR.Editor.BuildProcessors
{
var patcher = new ScriptingAssembliesJsonPatcher();
patcher.Load(file);
patcher.AddScriptingAssemblies(SettingsUtil.PatchingHotUpdateAssemblyFiles);
patcher.AddScriptingAssemblies(SettingsUtil.HotUpdateAssemblyFilesIncludePreserved);
patcher.Save(file);
}
}
@@ -123,7 +123,7 @@ namespace HybridCLR.Editor.BuildProcessors
{
var binFile = new UnityBinFile();
binFile.Load(binPath);
binFile.AddScriptingAssemblies(SettingsUtil.PatchingHotUpdateAssemblyFiles);
binFile.AddScriptingAssemblies(SettingsUtil.HotUpdateAssemblyFilesIncludePreserved);
binFile.Save(binPath);
Debug.Log($"[PatchScriptingAssemblyList] patch {binPath}");
}
@@ -142,7 +142,7 @@ namespace HybridCLR.Editor.BuildProcessors
foreach (string binPath in binFiles)
{
var patcher = new Dataunity3dPatcher();
patcher.ApplyPatch(binPath, SettingsUtil.PatchingHotUpdateAssemblyFiles);
patcher.ApplyPatch(binPath, SettingsUtil.HotUpdateAssemblyFilesIncludePreserved);
Debug.Log($"[PatchScriptingAssemblyList] patch {binPath}");
}
return true;
@@ -24,7 +24,7 @@ namespace HybridCLR.Editor.Commands
public static void GenerateAOTGenericReference(BuildTarget target)
{
var gs = SettingsUtil.HybridCLRSettings;
List<string> hotUpdateDllNames = SettingsUtil.HotUpdateAssemblyNames;
List<string> hotUpdateDllNames = SettingsUtil.HotUpdateAssemblyNamesExcludePreserved;
using (AssemblyReferenceDeepCollector collector = new AssemblyReferenceDeepCollector(MetaUtil.CreateHotUpdateAndAOTAssemblyResolver(target, hotUpdateDllNames), hotUpdateDllNames))
{
+3 -1
View File
@@ -18,7 +18,9 @@ namespace HybridCLR.Editor.Commands
var options = new Il2CppDef.Il2CppDefGenerator.Options()
{
UnityVersion = Application.unityVersion,
OutputFile = $"{SettingsUtil.LocalIl2CppDir}/libil2cpp/il2cpp-config.h",
HotUpdateAssemblies = SettingsUtil.HotUpdateAssemblyNamesIncludePreserved,
OutputFile = $"{SettingsUtil.LocalIl2CppDir}/libil2cpp/hybridclr/generated/UnityVersion.h",
OutputFile2 = $"{SettingsUtil.LocalIl2CppDir}/libil2cpp/hybridclr/generated/AssemblyManifest.cpp",
};
var g = new Il2CppDef.Il2CppDefGenerator(options);
+2 -2
View File
@@ -24,9 +24,9 @@ namespace HybridCLR.Editor.Commands
{
var ls = SettingsUtil.HybridCLRSettings;
List<string> hotfixAssemblies = SettingsUtil.HotUpdateAssemblyNames;
List<string> hotfixAssemblies = SettingsUtil.HotUpdateAssemblyNamesExcludePreserved;
var analyzer = new Analyzer(MetaUtil.CreateHotUpdateAndAOTAssemblyResolver(target, hotfixAssemblies), HybridCLRSettings.Instance.collectAssetReferenceTypes);
var analyzer = new Analyzer(MetaUtil.CreateHotUpdateAndAOTAssemblyResolver(target, hotfixAssemblies));
var refTypes = analyzer.CollectRefs(hotfixAssemblies);
Debug.Log($"[LinkGeneratorCommand] hotfix assembly count:{hotfixAssemblies.Count}, ref type count:{refTypes.Count} output:{Application.dataPath}/{ls.outputLinkFile}");
@@ -54,7 +54,7 @@ namespace HybridCLR.Editor.Commands
public static void GenerateMethodBridge(BuildTarget target)
{
List<string> hotUpdateDllNames = SettingsUtil.HotUpdateAssemblyNames;
List<string> hotUpdateDllNames = SettingsUtil.HotUpdateAssemblyNamesExcludePreserved;
using (AssemblyReferenceDeepCollector collector = new AssemblyReferenceDeepCollector(MetaUtil.CreateHotUpdateAndAOTAssemblyResolver(target, hotUpdateDllNames), hotUpdateDllNames))
{
var analyzer = new Analyzer(new Analyzer.Options
@@ -29,7 +29,7 @@ namespace HybridCLR.Editor.Commands
public static void GenerateReversePInvokeWrapper(BuildTarget target)
{
List<string> hotUpdateDlls = SettingsUtil.HotUpdateAssemblyNames;
List<string> hotUpdateDlls = SettingsUtil.HotUpdateAssemblyNamesExcludePreserved;
using (var cache = new AssemblyCache(MetaUtil.CreateHotUpdateAndAOTAssemblyResolver(target, hotUpdateDlls)))
{
var analyzer = new ReversePInvokeWrap.Analyzer(cache, hotUpdateDlls);
+4 -2
View File
@@ -38,6 +38,9 @@ namespace HybridCLR.Editor.Commands
BashUtil.RemoveDir(outputPath);
var buildOptions = BuildOptions.BuildScriptsOnly;
#if UNITY_2021_2_OR_NEWER
buildOptions |= BuildOptions.CleanBuildCache;
#endif
bool oldExportAndroidProj = EditorUserBuildSettings.exportAsGoogleAndroidProject;
#if UNITY_EDITOR_OSX
@@ -110,8 +113,7 @@ namespace HybridCLR.Editor.Commands
if (report.summary.result != UnityEditor.Build.Reporting.BuildResult.Succeeded)
{
Debug.LogError("GenerateStripedAOTDlls 失败");
return;
throw new Exception("GenerateStripedAOTDlls 失败");
}
Debug.Log($"GenerateStripedAOTDlls target:{target} group:{group} path:{outputPath}");
}
+27
View File
@@ -15,8 +15,12 @@ namespace HybridCLR.Editor.Il2CppDef
{
public class Options
{
public List<string> HotUpdateAssemblies { get; set; }
public string OutputFile { get; set; }
public string OutputFile2 { get; set; }
public string UnityVersion { get; set; }
}
@@ -30,6 +34,12 @@ namespace HybridCLR.Editor.Il2CppDef
private static readonly Regex s_unityVersionPat = new Regex(@"(\d+)\.(\d+)\.(\d+)");
public void Generate()
{
GenerateIl2CppConfig();
GeneratePlaceHolderAssemblies();
}
private void GenerateIl2CppConfig()
{
var frr = new FileRegionReplace(File.ReadAllText(_options.OutputFile));
@@ -55,5 +65,22 @@ namespace HybridCLR.Editor.Il2CppDef
frr.Commit(_options.OutputFile);
Debug.Log($"[HybridCLR.Editor.Il2CppDef.Generator] output:{_options.OutputFile}");
}
private void GeneratePlaceHolderAssemblies()
{
var frr = new FileRegionReplace(File.ReadAllText(_options.OutputFile2));
List<string> lines = new List<string>();
foreach (var ass in _options.HotUpdateAssemblies)
{
lines.Add($"\t\t\"{ass}\",");
}
frr.Replace("PLACE_HOLDER", string.Join("\n", lines));
frr.Commit(_options.OutputFile2);
Debug.Log($"[HybridCLR.Editor.Il2CppDef.Generator] output:{_options.OutputFile2}");
}
}
}
+17 -11
View File
@@ -41,7 +41,7 @@ namespace HybridCLR.Editor.Installer
p.StartInfo.CreateNoWindow = true;
p.StartInfo.RedirectStandardOutput = true;
p.StartInfo.RedirectStandardError = true;
string argsStr = string.Join(" ", args.Select(arg => "\"" + arg + "\""));
string argsStr = string.Join(" ", args);
p.StartInfo.Arguments = argsStr;
if (log)
{
@@ -56,15 +56,6 @@ namespace HybridCLR.Editor.Installer
}
}
public static bool ExistProgram(string prog)
{
#if UNITY_EDITOR_WIN
return RunCommand(".", "where", new string[] {prog}) == 0;
#elif UNITY_EDITOR_OSX || UNITY_EDITOR_LINUX
return RunCommand(".", "which", new string[] {prog}) == 0;
#endif
}
public static void RemoveDir(string dir, bool log = false)
{
@@ -97,6 +88,21 @@ namespace HybridCLR.Editor.Installer
Directory.CreateDirectory(dir);
}
private static void CopyWithCheckLongFile(string srcFile, string dstFile)
{
if (srcFile.Length > 255)
{
UnityEngine.Debug.LogError($"srcFile:{srcFile} path is too long. copy ignore!");
return;
}
if (dstFile.Length > 255)
{
UnityEngine.Debug.LogError($"dstFile:{dstFile} path is too long. copy ignore!");
return;
}
File.Copy(srcFile, dstFile);
}
public static void CopyDir(string src, string dst, bool log = false)
{
if (log)
@@ -107,7 +113,7 @@ namespace HybridCLR.Editor.Installer
Directory.CreateDirectory(dst);
foreach(var file in Directory.GetFiles(src))
{
File.Copy(file, $"{dst}/{Path.GetFileName(file)}");
CopyWithCheckLongFile(file, $"{dst}/{Path.GetFileName(file)}");
}
foreach(var subDir in Directory.GetDirectories(src))
{
+96 -124
View File
@@ -20,24 +20,60 @@ namespace HybridCLR.Editor.Installer
Ok,
}
public partial class InstallerController
public class InstallerController
{
private const string hybridclr_repo_path = "hybridclr_repo";
private const string il2cpp_plus_repo_path = "il2cpp_plus_repo";
public int MajorVersion => _curVersion.major;
private UnityVersion _curVersion;
private readonly UnityVersion _curVersion;
private readonly HybridclrVersionManifest _versionManifest;
private readonly HybridclrVersionInfo _curDefaultVersion;
public InstallerController()
{
_curVersion = ParseUnityVersion(Application.unityVersion);
_versionManifest = GetHybridCLRVersionManifest();
_curDefaultVersion = _versionManifest.versions.Find(v => v.unity_version == _curVersion.major.ToString());
}
public class UnityVersion
private HybridclrVersionManifest GetHybridCLRVersionManifest()
{
string versionFile = $"{SettingsUtil.ProjectDir}/{SettingsUtil.HybridCLRDataPathInPackage}/hybridclr_version.json";
return JsonUtility.FromJson<HybridclrVersionManifest>(File.ReadAllText(versionFile, Encoding.UTF8));
}
[Serializable]
class VersionDesc
{
public string branch;
//public string hash;
}
[Serializable]
class HybridclrVersionInfo
{
public string unity_version;
public VersionDesc hybridclr;
public VersionDesc il2cpp_plus;
}
[Serializable]
class HybridclrVersionManifest
{
public List<HybridclrVersionInfo> versions;
}
private class UnityVersion
{
public int major;
public int minor1;
@@ -120,78 +156,21 @@ namespace HybridCLR.Editor.Installer
}
}
private string _hybridclrLocalVersion;
public string HybridclrLocalVersion => _curDefaultVersion.hybridclr.branch;
public string HybridclrLocalVersion => _hybridclrLocalVersion != null ? _hybridclrLocalVersion : _hybridclrLocalVersion = GetHybridCLRLocalVersion();
public string Il2cppPlusLocalVersion => _curDefaultVersion.il2cpp_plus.branch;
public string HybridCLRRepoInstalledVersion
{
get { return EditorPrefs.GetString($"hybridclr_repo#{MajorVersion}"); }
set { EditorPrefs.SetString($"hybridclr_repo#{MajorVersion}", value); }
}
public string Il2CppRepoInstalledVersion
{
get { return EditorPrefs.GetString($"il2cpp_plus_repo#{MajorVersion}"); }
set { EditorPrefs.SetString($"il2cpp_plus_repo#{MajorVersion}", value); }
}
private string GetHybridCLRLocalVersion()
{
string workDir = SettingsUtil.HybridCLRDataDir;
string hybridclrRepoDir = $"{workDir}/{hybridclr_repo_path}";
if (Directory.Exists(hybridclrRepoDir))
{
var ret = BashUtil.RunCommand2(hybridclrRepoDir, "git",
new string[] { "log", "HEAD", "-n", "1", "--pretty=format:\"%H\"", },
false);
if (ret.ExitCode == 0)
{
return ret.StdOut.Trim();
}
else
{
return "ERROR";
}
}
return "";
}
private string _il2cppPlusLocalVersion;
public string Il2cppPlusLocalVersion => _il2cppPlusLocalVersion != null ? _il2cppPlusLocalVersion : _il2cppPlusLocalVersion = GetIl2cppPlusLocalVersion();
private string GetIl2cppPlusLocalVersion()
{
string workDir = SettingsUtil.HybridCLRDataDir;
string il2cppPlusRepoDir = $"{workDir}/{il2cpp_plus_repo_path}";
if (Directory.Exists(il2cppPlusRepoDir))
{
var ret = BashUtil.RunCommand2(il2cppPlusRepoDir, "git",
new string[] { "log", "HEAD", "-n", "1", "--pretty=format:\"%H\"", },
false);
if (ret.ExitCode == 0)
{
return ret.StdOut.Trim();
}
else
{
return "ERROR";
}
}
return "";
}
private string GetIl2CppPathByContentPath(string contentPath)
{
return $"{contentPath}/il2cpp";
}
public void InstallLocalHybridCLR(string hybridclrVer, string il2cppPlusVer)
public string ApplicationIl2cppPath => GetIl2CppPathByContentPath(EditorApplication.applicationContentsPath);
public void InstallDefaultHybridCLR()
{
RunInitLocalIl2CppData(GetIl2CppPathByContentPath(EditorApplication.applicationContentsPath), _curVersion, hybridclrVer, il2cppPlusVer);
InstallFromLocal(PrepareLibil2cppWithHybridclrFromGitRepo());
}
public bool HasInstalledHybridCLR()
@@ -218,15 +197,54 @@ namespace HybridCLR.Editor.Installer
#endif
}
private void RunInitLocalIl2CppData(string editorIl2cppPath, UnityVersion version, string hybridclrVer, string il2cppPlusVer)
void CloneBranch(string workDir, string repoUrl, string branch, string repoDir)
{
#if UNITY_EDITOR_WIN
if (!BashUtil.ExistProgram("git"))
{
throw new Exception($"安装本地il2cpp需要使用git从远程拉取仓库,请先安装git");
}
#endif
BashUtil.RemoveDir(repoDir);
BashUtil.RunCommand(workDir, "git", new string[] {"clone", "-b", branch, "--depth", "1", repoUrl, repoDir});
}
private string PrepareLibil2cppWithHybridclrFromGitRepo()
{
string workDir = SettingsUtil.HybridCLRDataDir;
Directory.CreateDirectory(workDir);
//BashUtil.RecreateDir(workDir);
// clone hybridclr
string hybridclrRepoURL = HybridCLRSettings.Instance.hybridclrRepoURL;
string hybridclrRepoDir = $"{workDir}/{hybridclr_repo_path}";
CloneBranch(workDir, hybridclrRepoURL, _curDefaultVersion.hybridclr.branch, hybridclrRepoDir);
if (!Directory.Exists(hybridclrRepoDir))
{
throw new Exception($"clone hybridclr fail. url: {hybridclrRepoURL}");
}
// clone il2cpp_plus
string il2cppPlusRepoURL = HybridCLRSettings.Instance.il2cppPlusRepoURL;
string il2cppPlusRepoDir = $"{workDir}/{il2cpp_plus_repo_path}";
CloneBranch(workDir, il2cppPlusRepoURL, _curDefaultVersion.il2cpp_plus.branch, il2cppPlusRepoDir);
if (!Directory.Exists(il2cppPlusRepoDir))
{
throw new Exception($"clone il2cpp_plus fail. url: {il2cppPlusRepoDir}");
}
Directory.Move($"{hybridclrRepoDir}/hybridclr", $"{il2cppPlusRepoDir}/libil2cpp/hybridclr");
return $"{il2cppPlusRepoDir}/libil2cpp";
}
public void InstallFromLocal(string libil2cppWithHybridclrSourceDir)
{
RunInitLocalIl2CppData(ApplicationIl2cppPath, libil2cppWithHybridclrSourceDir, _curVersion);
}
private void RunInitLocalIl2CppData(string editorIl2cppPath, string libil2cppWithHybridclrSourceDir, UnityVersion version)
{
if (!IsComaptibleVersion())
{
Debug.LogError($"il2cpp 版本不兼容,最小版本为 {GetCurrentUnityVersionMinCompatibleVersionStr()}");
return;
}
string workDir = SettingsUtil.HybridCLRDataDir;
Directory.CreateDirectory(workDir);
//BashUtil.RecreateDir(workDir);
@@ -235,47 +253,6 @@ namespace HybridCLR.Editor.Installer
BashUtil.RemoveDir(buildiOSDir);
BashUtil.CopyDir($"{SettingsUtil.HybridCLRDataPathInPackage}/iOSBuild", buildiOSDir, true);
// clone hybridclr
string hybridclrRepoURL = HybridCLRSettings.Instance.hybridclrRepoURL;
string hybridclrRepoDir = $"{workDir}/{hybridclr_repo_path}";
{
BashUtil.RemoveDir(hybridclrRepoDir);
string[] args = new string[]
{
"clone",
"--depth=1",
"-b",
hybridclrVer,
hybridclrRepoURL,
hybridclrRepoDir,
};
var ret = BashUtil.RunCommand(workDir, "git", args);
//if (ret != 0)
//{
// throw new Exception($"git clone 失败");
//}
}
// clone il2cpp_plus
string il2cppPlusRepoURL = HybridCLRSettings.Instance.il2cppPlusRepoURL;
string il2cppPlusRepoDir = $"{workDir}/{il2cpp_plus_repo_path}";
{
BashUtil.RemoveDir(il2cppPlusRepoDir);
string[] args = new string[]
{
"clone",
"--depth=1",
"-b",
il2cppPlusVer,
il2cppPlusRepoURL,
il2cppPlusRepoDir,
};
var ret = BashUtil.RunCommand(workDir, "git", args);
//if (ret != 0)
//{
// throw new Exception($"git clone 失败");
//}
}
// create LocalIl2Cpp
string localUnityDataDir = SettingsUtil.LocalUnityDataDir;
@@ -289,8 +266,7 @@ namespace HybridCLR.Editor.Installer
// replace libil2cpp
string dstLibil2cppDir = $"{SettingsUtil.LocalIl2CppDir}/libil2cpp";
BashUtil.CopyDir($"{il2cppPlusRepoDir}/libil2cpp", dstLibil2cppDir, true);
BashUtil.CopyDir($"{hybridclrRepoDir}/hybridclr", $"{dstLibil2cppDir}/hybridclr", true);
BashUtil.CopyDir($"{libil2cppWithHybridclrSourceDir}", dstLibil2cppDir, true);
// clean Il2cppBuildCache
BashUtil.RemoveDir($"{SettingsUtil.ProjectDir}/Library/Il2cppBuildCache", true);
@@ -312,15 +288,11 @@ namespace HybridCLR.Editor.Installer
}
if (HasInstalledHybridCLR())
{
Debug.Log("安装成功!");
_hybridclrLocalVersion = null;
_il2cppPlusLocalVersion = null;
HybridCLRRepoInstalledVersion = hybridclrVer;
Il2CppRepoInstalledVersion = il2cppPlusVer;
Debug.Log("安装成功");
}
else
{
Debug.LogError("安装失败!");
Debug.LogError("安装失败");
}
}
}
+46 -40
View File
@@ -1,4 +1,5 @@
using System;
using System.IO;
using System.Reflection;
using UnityEditor;
using UnityEngine;
@@ -10,22 +11,13 @@ namespace HybridCLR.Editor.Installer
{
private InstallerController _controller;
string _hybridclrVersion;
string _il2cppPlusVersion;
private bool _installFromDir;
private string _installLibil2cppWithHybridclrSourceDir;
private void OnEnable()
{
_controller = new InstallerController();
_hybridclrVersion = _controller.HybridCLRRepoInstalledVersion;
if (string.IsNullOrWhiteSpace(_hybridclrVersion))
{
_hybridclrVersion = "1.0";
}
_il2cppPlusVersion = _controller.Il2CppRepoInstalledVersion;
if (string.IsNullOrWhiteSpace(_il2cppPlusVersion))
{
_il2cppPlusVersion = $"{_controller.MajorVersion}-1.0";
}
}
private void OnGUI()
@@ -44,34 +36,33 @@ namespace HybridCLR.Editor.Installer
SettingsService.OpenProjectSettings("Project/HybridCLR Settings");
}
bool hasInstall = _controller.HasInstalledHybridCLR();
GUILayout.Space(10f);
EditorGUILayout.BeginVertical("box");
bool hasInstall = _controller.HasInstalledHybridCLR();
EditorGUILayout.LabelField($"安装状态:{(hasInstall ? "已安装" : "未安装")}", EditorStyles.boldLabel);
GUILayout.Space(10f);
if (hasInstall)
{
EditorGUILayout.LabelField($"HybridCLR 版本: {_controller.HybridclrLocalVersion}");
GUILayout.Space(5f);
EditorGUILayout.LabelField($"il2cpp_plus 版本: {_controller.Il2cppPlusLocalVersion}");
GUILayout.Space(5f);
//GUIInstallButton("检查更新", "检查", UpdateHybridCLR);
//GUILayout.Space(40f);
}
EditorGUILayout.LabelField($"HybridCLR 版本: {_controller.HybridclrLocalVersion}");
GUILayout.Space(5f);
EditorGUILayout.LabelField($"il2cpp_plus 版本: {_controller.Il2cppPlusLocalVersion}");
GUILayout.Space(5f);
//GUIInstallButton("检查更新", "检查", UpdateHybridCLR);
//GUILayout.Space(40f);
GUILayout.Space(10f);
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("待安装的 hybridclr 仓库版本号(或branch或tag)(默认取最新版本):", GUILayout.MaxWidth(400));
_hybridclrVersion = EditorGUILayout.TextField(_hybridclrVersion);
EditorGUILayout.EndHorizontal();
//EditorGUILayout.BeginHorizontal();
//EditorGUILayout.LabelField("待安装的 hybridclr 仓库版本号(或branch或tag)(默认取最新版本):", GUILayout.MaxWidth(400));
//_hybridclrVersion = EditorGUILayout.TextField(_hybridclrVersion);
//EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField($"待安装的 il2cpp_plus 仓库版本号(或branch或tag)(默认取{_controller.MajorVersion}-main分支最新版本):", GUILayout.MaxWidth(400));
_il2cppPlusVersion = EditorGUILayout.TextField(_il2cppPlusVersion);
EditorGUILayout.EndHorizontal();
//EditorGUILayout.BeginHorizontal();
//EditorGUILayout.LabelField($"待安装的 il2cpp_plus 仓库版本号(或branch或tag)(默认取{_controller.MajorVersion}-main分支最新版本):", GUILayout.MaxWidth(400));
//_il2cppPlusVersion = EditorGUILayout.TextField(_il2cppPlusVersion);
//EditorGUILayout.EndHorizontal();
GUIInstallButton("安装hybridclr+il2cpp_plus代码到本地目录", "安装");
@@ -80,6 +71,17 @@ namespace HybridCLR.Editor.Installer
private void GUIInstallButton(string content, string button)
{
EditorGUILayout.BeginHorizontal();
_installFromDir = EditorGUILayout.Toggle("从本地复制libil2cpp", _installFromDir);
EditorGUI.BeginDisabledGroup(!_installFromDir);
EditorGUILayout.TextField(_installLibil2cppWithHybridclrSourceDir, GUILayout.Width(400));
if (GUILayout.Button("选择目录", GUILayout.Width(100)))
{
_installLibil2cppWithHybridclrSourceDir = EditorUtility.OpenFolderPanel("选择libil2cpp目录", Application.dataPath, "libil2cpp");
}
EditorGUI.EndDisabledGroup();
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(content);
if (GUILayout.Button(button, GUILayout.Width(100)))
@@ -93,20 +95,24 @@ namespace HybridCLR.Editor.Installer
private void InstallLocalHybridCLR()
{
if (!_controller.IsComaptibleVersion())
if (_installFromDir)
{
Debug.LogError($"il2cpp 版本不兼容,最小版本为 {_controller.GetCurrentUnityVersionMinCompatibleVersionStr()}");
return;
if (!Directory.Exists(_installLibil2cppWithHybridclrSourceDir))
{
Debug.LogError($"本地libil2cpp复制目录不存在. '{_installLibil2cppWithHybridclrSourceDir}'");
return;
}
if (!File.Exists($"{_installLibil2cppWithHybridclrSourceDir}/il2cpp-config.h") || !File.Exists($"{_installLibil2cppWithHybridclrSourceDir}/hybridclr/RuntimeApi.cpp"))
{
Debug.LogError($"本地libil2cpp不是合法有效的源码目录. '{_installLibil2cppWithHybridclrSourceDir}'");
return;
}
_controller.InstallFromLocal(_installLibil2cppWithHybridclrSourceDir);
}
if (string.IsNullOrWhiteSpace(_hybridclrVersion))
else
{
_hybridclrVersion = "main";
_controller.InstallDefaultHybridCLR();
}
if (string.IsNullOrWhiteSpace(_il2cppPlusVersion))
{
_il2cppPlusVersion = $"{_controller.MajorVersion}-main";
}
_controller.InstallLocalHybridCLR(_hybridclrVersion, _il2cppPlusVersion);
}
}
}
+2 -53
View File
@@ -14,12 +14,10 @@ namespace HybridCLR.Editor.Link
public class Analyzer
{
private readonly IAssemblyResolver _resolver;
private readonly bool _analyzeAssetType;
public Analyzer(IAssemblyResolver resolver, bool analyzeAssetType)
public Analyzer(IAssemblyResolver resolver)
{
_resolver = resolver;
_analyzeAssetType = analyzeAssetType;
}
public HashSet<TypeRef> CollectRefs(List<string> rootAssemblies)
@@ -31,7 +29,7 @@ namespace HybridCLR.Editor.Link
var typeRefs = new HashSet<TypeRef>(TypeEqualityComparer.Instance);
foreach (var rootAss in rootAssemblies)
{
var dnAss = assCollector.LoadModule(rootAss, _analyzeAssetType);
var dnAss = assCollector.LoadModule(rootAss, false);
foreach (var type in dnAss.GetTypeRefs())
{
if (!rootAssemblyNames.Contains(type.DefinitionAssembly.Name.ToString()))
@@ -41,58 +39,9 @@ namespace HybridCLR.Editor.Link
}
}
if (_analyzeAssetType)
{
var modsExludeRoots = assCollector.LoadedModules
.Where(e => !rootAssemblyNames.Contains(e.Key))
.ToDictionary(e => e.Key, e => e.Value);
CollectObjectTypeInAssets(modsExludeRoots, typeRefs);
}
assCollector.Dispose();
return typeRefs;
}
}
public void CollectObjectTypeInAssets(Dictionary<string, ModuleDefMD> mods, HashSet<TypeRef> typeRefs)
{
var objTypes = new HashSet<Type>();
string[] guids = AssetDatabase.FindAssets("t:Object", new[] { "Assets" });
foreach (string guid in guids)
{
string assetPath = AssetDatabase.GUIDToAssetPath(guid);
Type mainAssetType = AssetDatabase.GetMainAssetTypeAtPath(assetPath);
if (mainAssetType == typeof(SceneAsset))
{
}
else
{
UnityEngine.Object[] objs = AssetDatabase.LoadAllAssetsAtPath(assetPath);
foreach (UnityEngine.Object obj in objs)
{
if (obj != null)
{
objTypes.Add(obj.GetType());
}
}
}
}
var importers = mods.ToDictionary(e => e.Key, e => new Importer(e.Value));
//Debug.Log($"importers count:{importers.Count} importers:{string.Join(",", importers.Keys)}");
foreach (var type in objTypes)
{
if (importers.TryGetValue(type.Assembly.GetName().Name, out var im))
{
typeRefs.Add((TypeRef)im.Import(type));
//Debug.Log($"== add asset type:{type}");
}
else
{
//Debug.Log($"== ignore asset type:{type} {type.Assembly.GetName().Name}");
}
}
}
}
}
+8 -1
View File
@@ -16,7 +16,14 @@ namespace HybridCLR.Editor.Meta
}
if (throwExIfNotFind)
{
throw new Exception($"resolve assembly:{assemblyName} 失败! 如果是热更新dll找不到,请先运行`HybridCLR/CompileDll/ActiveBuildTarget`编译生成热更新dll。如果是AOT dll找不到,请先运行`HybridCLR/Generate/LinkXml`,接着在`Build Settings`中打包或者导出工程来生成AOT dll");
if (SettingsUtil.HotUpdateAssemblyNamesIncludePreserved.Contains(assemblyName))
{
throw new Exception($"resolve 热更新 dll:{assemblyName} 失败!请确保已经编译了热更新dll或者外部热更新路径中配置了正确的值。更多请参阅常见错误文档");
}
else
{
throw new Exception($"resolve AOT dll:{assemblyName} 失败! 请确保主工程已经引用了该dll并且正确生成了裁剪后的AOT dll。更多请参阅常见错误文档");
}
}
return null;
}
@@ -20,7 +20,6 @@ namespace HybridCLR.Editor
private SerializedProperty _externalHotUpdateAssembliyDirs;
private SerializedProperty _strippedAOTDllOutputRootDir;
private SerializedProperty _patchAOTAssemblies;
private SerializedProperty _collectAssetReferenceTypes;
private SerializedProperty _outputLinkFile;
private SerializedProperty _outputAOTGenericReferenceFile;
private SerializedProperty _maxGenericReferenceIteration;
@@ -48,7 +47,6 @@ namespace HybridCLR.Editor
_externalHotUpdateAssembliyDirs = _serializedObject.FindProperty("externalHotUpdateAssembliyDirs");
_strippedAOTDllOutputRootDir = _serializedObject.FindProperty("strippedAOTDllOutputRootDir");
_patchAOTAssemblies = _serializedObject.FindProperty("patchAOTAssemblies");
_collectAssetReferenceTypes = _serializedObject.FindProperty("collectAssetReferenceTypes");
_outputLinkFile = _serializedObject.FindProperty("outputLinkFile");
_outputAOTGenericReferenceFile = _serializedObject.FindProperty("outputAOTGenericReferenceFile");
_maxGenericReferenceIteration = _serializedObject.FindProperty("maxGenericReferenceIteration");
@@ -137,7 +135,6 @@ namespace HybridCLR.Editor
EditorGUILayout.PropertyField(_externalHotUpdateAssembliyDirs);
EditorGUILayout.PropertyField(_strippedAOTDllOutputRootDir);
EditorGUILayout.PropertyField(_patchAOTAssemblies);
EditorGUILayout.PropertyField(_collectAssetReferenceTypes);
EditorGUILayout.PropertyField(_outputLinkFile);
EditorGUILayout.PropertyField(_outputAOTGenericReferenceFile);
EditorGUILayout.PropertyField(_maxGenericReferenceIteration);
-3
View File
@@ -38,9 +38,6 @@ namespace HybridCLR.Editor
[Header("补充元数据AOT dlls")]
public string[] patchAOTAssemblies;
[Header("生成link.xml时扫描asset中引用的类型")]
public bool collectAssetReferenceTypes;
[Header("生成的link.xml路径")]
public string outputLinkFile = "HybridCLRData/Generated/link.xml";
+15 -11
View File
@@ -65,9 +65,9 @@ namespace HybridCLR.Editor
}
/// <summary>
/// 所有热更新dll列表。放到此列表中的dll在打包时OnFilterAssemblies回调中被过滤。
/// 热更新dll列表。不包含 preserveHotUpdateAssemblies。
/// </summary>
public static List<string> HotUpdateAssemblyNames
public static List<string> HotUpdateAssemblyNamesExcludePreserved
{
get
{
@@ -84,31 +84,35 @@ namespace HybridCLR.Editor
}
}
public static List<string> HotUpdateAssemblyFiles => HotUpdateAssemblyNames.Select(dll => dll + ".dll").ToList();
public static List<string> HotUpdateAssemblyFilesExcludePreserved => HotUpdateAssemblyNamesExcludePreserved.Select(dll => dll + ".dll").ToList();
public static List<string> PatchingHotUpdateAssemblyFiles
public static List<string> HotUpdateAssemblyNamesIncludePreserved
{
get
{
List<string> patchingList = HotUpdateAssemblyFiles;
List<string> allAsses = HotUpdateAssemblyNamesExcludePreserved;
string[] preserveAssemblyNames = HybridCLRSettings.Instance.preserveHotUpdateAssemblies;
if (preserveAssemblyNames != null && preserveAssemblyNames.Length > 0)
{
foreach(var assemblyName in preserveAssemblyNames)
foreach (var assemblyName in preserveAssemblyNames)
{
string dllFileName = assemblyName + ".dll";
if (patchingList.Contains(dllFileName))
if (allAsses.Contains(assemblyName))
{
throw new Exception($"[PatchingHotUpdateAssemblyFiles] assembly:'{assemblyName}' 重复");
throw new Exception($"[HotUpdateAssemblyNamesIncludePreserved] assembly:'{assemblyName}' 重复");
}
patchingList.Add(dllFileName);
allAsses.Add(assemblyName);
}
}
return patchingList;
return allAsses;
}
}
public static List<string> HotUpdateAssemblyFilesIncludePreserved => HotUpdateAssemblyNamesIncludePreserved.Select(ass => ass + ".dll").ToList();
public static List<string> AOTAssemblyNames => HybridCLRSettings.Instance.patchAOTAssemblies.ToList();
public static HybridCLRSettings HybridCLRSettings => HybridCLRSettings.Instance;
}
}
+7
View File
@@ -1,4 +1,11 @@
# hybridclr_unity
Unity Package for HybridCLR
## 改动日志
- v2.3.0 支持从本地目录直接复制hybridclr源码。轻微修复2019版本某些情况下路径过长导致安装失败的问题。
- v2.2.0 支持2020.3.47及2021.3.23
- v2.0.5 Installer使用tag而不是commit id,安装时不必拉取整个branch,大幅缩短安装时间
+47
View File
@@ -0,0 +1,47 @@
# 发布日志
## 2.4.2
### 改动
- 支持 2020.3.48,最后一个2020LTS版本
- 支持 2021.3.25
- hybridclr 升级到 v2.3.1
- il2cpp_plus 升级到 v2020-2.2.1 、v2021-2.2.1
## 2.4.1
### 修复
- 修复遗漏 RELEASELOG.md.meta 文件的问题
## 2.4.0
### 改动
- CheckSettings中检查ScriptingBackend及ApiCompatibleLevel,切换为正确的值
- hybridclr 升级到v2.3.0版本
- il2cpp_plus 升级到v2019-2.2.0、v2020-2.2.0、v2021-2.2.0版本
### 修复
- 新增 MsvcStdextWorkaround.cs 解决2020 vs下stdext编译错误的问题
- 修复当struct只包含一个float或double字段时,在arm64上计算桥接函数签名错误的bug
## 2.3.1
### 修复
- 修复本地复制libil2cpp却仍然从仓库下载安装的bug
## 2.3.0
### 改动
- Installer支持从本地目录复制改造后的libil2cpp
### 修复
- 修复2019版本MonoBleedingEdge的子目录中包含了过长路径的文件导致Installer复制文件出错的问题
@@ -1,5 +1,5 @@
fileFormatVersion: 2
guid: a96a2c46326d2a84984c2820bd4bfc91
guid: 8e53ce54bd8e88c4785c625555308dba
TextScriptImporter:
externalObjects: {}
userData:
+9 -7
View File
@@ -1,21 +1,23 @@
{
"name": "com.focus-creative-games.hybridclr_unity",
"version": "1.0.12",
"version": "2.4.2",
"displayName": "HybridCLR",
"description": "Unity package for HybridCLR. It includes editor and runtime scripts and assets for HybridCLR",
"description": "HybridCLR is a fully featured, zero-cost, high-performance, low-memory solution for Unity's all-platform native c# hotupdate.",
"category": "Runtime",
"documentationUrl": "https://focus-creative-games.github.io/hybridclr/index",
"changelogUrl": "https://github.com/focus-creative-games/hybridclr/commits/main",
"documentationUrl": "https://focus-creative-games.github.io/hybridclr-doc",
"changelogUrl": "https://focus-creative-games.github.io/hybridclr-doc/#/other/changelog",
"licensesUrl": "https://github.com/focus-creative-games/hybridclr/blob/main/LICENSE",
"keywords": [
"HybridCLR",
"hotupdate",
"hotfix",
"code philosophy",
"unity",
"focus-creative-games"
],
"author": {
"name": "focus-creative-games",
"email": "hybridclr@focus-creative-games.com",
"url": "https://github.com/focus-creative-games/"
"name": "Code Philosophy",
"email": "hybridclr@code-philosophy.com",
"url": "https://code-philosophy.com"
}
}