Help with AOT compilation (with MonoPInvokeCallback)

Code (CSharp):

1.         internal static IntPtr GetThunk(MethodInfo method, string funcType = null)
2.         {
3.             Type dt;
4.             if (funcType != null)
5.                 dt = typeof(Interop).GetNestedType(funcType) as Type;
6.             else
7.                 dt = GetPrototype(method.Name);
8.             if (dt != null)
9.             {
10.                 Delegate d = Delegate.CreateDelegate(dt, method);
11. #if AOT
12.                 IntPtr fp = Marshal.GetFunctionPointerForDelegate(d);
13. #else
14.                 IntPtr tmp = Marshal.AllocHGlobal(IntPtr.Size);
15.                 Thunk cb = new Thunk(d);
16.                 Marshal.StructureToPtr(cb, tmp, false);
17.                 IntPtr fp = Marshal.ReadIntPtr(tmp, 0);
18.                 Marshal.FreeHGlobal(tmp);
19. #endif
20.                 keepAlive.Add(d);
21.                 return fp;
22.             }
23.             return IntPtr.Zero;
24.         }

inside AOT macro:
IntPtr fp = Marshal.GetFunctionPointerForDelegate(d);
when run the program this line of code will trough error:
NotSupportedException: To marshal a managed method, please add an attribute named 'MonoPInvokeCallback' to the method definition.
at System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegateInternal (System.Delegate d) [0x00000] in <00000000000000000000000000000000>:0
at System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate (System.Delegate d) [0x00000] in <00000000000000000000000000000000>:0
at Python.Runtime.Interop.GetThunk (System.Reflection.MethodInfo method, System.String funcType) [0x00000] in <00000000000000000000000000000000>:0

 

we get stuck with iOS build.
Please help, any Unity Technologies staff would be appreciated.

 

Yeah, What u said is very straightforward and clear, and we've been doing it for quite a while.

Code (CSharp):

1. [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
2. internal struct Thunk
3. {
4.      public Delegate fn;
5.  
6.       public Thunk(Delegate d)
7.       {
8.             fn = d;
9.       }
10.  }
11.  
12. IntPtr CreateAOTCompatibleFP(MethodInfo method, Type dt)
13. {
14.     Delegate d = Delegate.CreateDelegate(dt, method);
15.     IntPtr tmp = Marshal.AllocHGlobal(IntPtr.Size);
16.     Thunk cb = new Thunk(d); //THIS IS WHERE IL2CPP COMPLAINS
17.     Marshal.StructureToPtr(cb, tmp, false);
18.     IntPtr fp = Marshal.ReadIntPtr(tmp, 0);
19.     Marshal.FreeHGlobal(tmp);
20.     return fp;
21. }
22.  
23. //The delegatetype we passed in
24. [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
25. public delegate IntPtr BinaryFunc(IntPtr ob, IntPtr arg);
26.  
27. CreateAOTCompatibleFP(instancemethod, typeof(BinaryFunc))
28.  
29.  

Since it's an delegate of instance method, we don't know how to correctly create a static MonoPInvokeCallbackAttribute method.

A guy who succeed it said it should be done by using Mono.Cecil to inject IL code to the managed method before il2cpp compiles, but we don't know the details.

This is piece of code from Pythonnet. And UnityTechnology also forked it and made some modifications on it. I think the Unity engineer who forked pythonnet might know how to do it.

 

thx for your patience. Since we are lack of insights of compilers, so maybe more information could be more precise.

Code (CSharp):

1. class MetaType
2. {
3.        public static IntPtr __instancecheck__(IntPtr tp, IntPtr args)
4.         {
5.             return DoInstanceCheck(tp, args, false);
6.         }
7. }
8.  
9. //The final piece of code that calls the method
10.  
11. mdef = WriteMethodDef(
12.         mdef,
13.         "__instancecheck__",
14.         Interop.GetAOTCompatibleFP(typeof(MetaType).GetMethod("__instancecheck__"), typeof(BinaryFunc))
15. );

If there is any mistake I made, feel free to point it out.

 

To write a function pointer(Unmanaged) of __instancecheck__ method(Managed) to a Managed PythonMethod object, interactable with CPython runtime.
Project url: https://github.com/joonhwan/pythonnet

 

Code (CSharp):

1. typeof(MetaType).GetMethod("__instancecheck__")

Well, i realized it's not an instance method.
OK, thank you so much.

 

C

Confirmed working.
Thank you!!!

PS: now I know why a guy said should use mono.cecil to inject IL code.
Just inject code to any method like __instancecheck__, marking with MonoPInvokeAttribute, that will work too.