From 51d4c0c650b332333bd3ab49816ff54940f4d2b7 Mon Sep 17 00:00:00 2001
From: liiir1985 <liiir1985@hotmail.com>
Date: Thu, 30 Nov 2023 11:11:40 +0800
Subject: [PATCH] Improve missing method handling, better exception handling is
 now possible

---
 ILRuntime/CLR/Method/ILMethod.cs              | 38 ++++++++++-----
 ILRuntime/Runtime/Enviorment/AppDomain.cs     | 13 +++++
 ILRuntime/Runtime/Intepreter/ILIntepreter.cs  |  9 ++++
 ILRuntimeTestBase/TestFramework/TestClass3.cs | 26 +++++++++-
 TestCases/CLRBindingTest.cs                   | 47 ++++++++++++++++++-
 5 files changed, 118 insertions(+), 15 deletions(-)

diff --git a/ILRuntime/CLR/Method/ILMethod.cs b/ILRuntime/CLR/Method/ILMethod.cs
index dbf305a1..e4c12dde 100644
--- a/ILRuntime/CLR/Method/ILMethod.cs
+++ b/ILRuntime/CLR/Method/ILMethod.cs
@@ -736,29 +736,41 @@ unsafe void InitToken(ref OpCode code, object token, Dictionary<Mono.Cecil.Cil.I
                 case OpCodeEnum.Ldvirtftn:
                 case OpCodeEnum.Callvirt:
                     {
-                        bool invalidToken;
-                        var m = appdomain.GetMethod(token, declaringType, this, out invalidToken);
-                        if (m != null)
+                        try
                         {
-                            if(code.Code == OpCodeEnum.Callvirt && m is ILMethod)
+                            bool invalidToken;
+                            var m = appdomain.GetMethod(token, declaringType, this, out invalidToken);
+                            if (m != null)
                             {
-                                ILMethod ilm = (ILMethod)m;
-                                if (!ilm.def.IsAbstract && !ilm.def.IsVirtual && !ilm.DeclearingType.IsInterface)
-                                    code.Code = OpCodeEnum.Call;
+                                if (code.Code == OpCodeEnum.Callvirt && m is ILMethod)
+                                {
+                                    ILMethod ilm = (ILMethod)m;
+                                    if (!ilm.def.IsAbstract && !ilm.def.IsVirtual && !ilm.DeclearingType.IsInterface)
+                                        code.Code = OpCodeEnum.Call;
+                                }
+                                if (invalidToken)
+                                    code.TokenInteger = m.GetHashCode();
+                                else
+                                    code.TokenInteger = token.GetHashCode();
                             }
-                            if (invalidToken)
-                                code.TokenInteger = m.GetHashCode();
                             else
-                                code.TokenInteger = token.GetHashCode();
+                            {
+                                //Cannot find method or the method is dummy
+                                MethodReference _ref = (MethodReference)token;
+                                int paramCnt = _ref.HasParameters ? _ref.Parameters.Count : 0;
+                                if (_ref.HasThis)
+                                    paramCnt++;
+                                code.TokenLong = paramCnt;
+                            }
                         }
-                        else
+                        catch(Exception e)
                         {
-                            //Cannot find method or the method is dummy
+                            appdomain.CacheException(e);
                             MethodReference _ref = (MethodReference)token;
                             int paramCnt = _ref.HasParameters ? _ref.Parameters.Count : 0;
                             if (_ref.HasThis)
                                 paramCnt++;
-                            code.TokenLong = paramCnt;
+                            code.TokenLong = (long)paramCnt | ((long)e.GetHashCode() << 32);
                         }
                     }
                     break;
diff --git a/ILRuntime/Runtime/Enviorment/AppDomain.cs b/ILRuntime/Runtime/Enviorment/AppDomain.cs
index 1d8583e5..7a9ea40b 100644
--- a/ILRuntime/Runtime/Enviorment/AppDomain.cs
+++ b/ILRuntime/Runtime/Enviorment/AppDomain.cs
@@ -56,6 +56,7 @@ public class AppDomain
         List<IType> typesByIndex = new List<IType>();
         ThreadSafeDictionary<int, IType> mapTypeToken = new ThreadSafeDictionary<int, IType>();
         ThreadSafeDictionary<int, IMethod> mapMethod = new ThreadSafeDictionary<int, IMethod>();
+        ThreadSafeDictionary<int, Exception> mapException = new ThreadSafeDictionary<int, Exception>();
         ThreadSafeDictionary<long, string> mapString = new ThreadSafeDictionary<long, string>();
         Dictionary<System.Reflection.MethodBase, CLRRedirectionDelegate> redirectMap = new Dictionary<System.Reflection.MethodBase, CLRRedirectionDelegate>();
         Dictionary<System.Reflection.FieldInfo, CLRFieldGetterDelegate> fieldGetterMap = new Dictionary<System.Reflection.FieldInfo, CLRFieldGetterDelegate>();
@@ -1544,6 +1545,18 @@ bool IsInvalidMethodReference(MethodReference _ref)
             }
             return false;
         }
+
+        internal void CacheException(Exception ex)
+        {
+            mapException[ex.GetHashCode()] = ex;
+        }
+
+        internal Exception GetException(int token)
+        {
+            if (mapException.TryGetValue(token, out var ex))
+                return ex;
+            return null;
+        }
         
         
         internal IMethod GetMethod(object token, ILType contextType, ILMethod contextMethod, out bool invalidToken)
diff --git a/ILRuntime/Runtime/Intepreter/ILIntepreter.cs b/ILRuntime/Runtime/Intepreter/ILIntepreter.cs
index 2b5c2ca7..3ac3daf8 100644
--- a/ILRuntime/Runtime/Intepreter/ILIntepreter.cs
+++ b/ILRuntime/Runtime/Intepreter/ILIntepreter.cs
@@ -1971,6 +1971,15 @@ public object Run(ILMethod method, object instance, object[] p)
                                     IMethod m = domain.GetMethod(ip->TokenInteger);
                                     if (m == null)
                                     {
+                                        int exToken = (int)(((ulong)ip->TokenLong & 0xFFFFFFFF00000000) >> 32);
+                                        if (exToken > 0)
+                                        {
+                                            var ex = domain.GetException(exToken);
+                                            if (ex != null)
+                                            {
+                                                throw new ILRuntimeException(ex.Message, this, method, ex);
+                                            }
+                                        }
                                         //Irrelevant method
                                         int cnt = (int)ip->TokenLong;
                                         //Balance the stack
diff --git a/ILRuntimeTestBase/TestFramework/TestClass3.cs b/ILRuntimeTestBase/TestFramework/TestClass3.cs
index 28231a6d..cdbc33c0 100644
--- a/ILRuntimeTestBase/TestFramework/TestClass3.cs
+++ b/ILRuntimeTestBase/TestFramework/TestClass3.cs
@@ -1,4 +1,5 @@
-using System;
+#define TEST_MISSING_METHOD
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -103,6 +104,29 @@ public void Emit<T>(T obj)
         {
             LoadAsset("123", obj);
         }
+
+#if TEST_MISSING_METHOD
+        public int missingField;
+        public void MissingMethodGeneric<T>(T obj)
+        {
+
+        }
+
+        public void MissingMethod()
+        {
+
+        }
+
+        public static void MissingStaticMethod()
+        {
+
+        }
+#endif
     }
 
+#if TEST_MISSING_METHOD
+    public class MissingType
+    {
+    }
+#endif
 }
diff --git a/TestCases/CLRBindingTest.cs b/TestCases/CLRBindingTest.cs
index 29c0784d..ffdd3d76 100644
--- a/TestCases/CLRBindingTest.cs
+++ b/TestCases/CLRBindingTest.cs
@@ -1,4 +1,7 @@
-using ILRuntimeTest;
+using ILRuntime.Runtime.CLRBinding;
+using ILRuntime.Runtime.Intepreter;
+using ILRuntimeTest;
+using ILRuntimeTest.TestFramework;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -139,5 +142,47 @@ public static void CLRBindingTestEnd()
         {
             ILRuntimeTest.TestBase.TestSession.LastSession.Appdomain.AllowUnboundCLRMethod = true;
         }
+
+        [ILRuntimeTest.ILRuntimeTest(ExpectException = typeof(ILRuntimeException))]
+        public static void CLRBindingTestMissing01()
+        {
+            ILRuntimeTest.TestFramework.TestCLRBinding binding = new ILRuntimeTest.TestFramework.TestCLRBinding();
+            binding.MissingMethod();
+        }
+
+        [ILRuntimeTest.ILRuntimeTest(ExpectException = typeof(ILRuntimeException))]
+        public static void CLRBindingTestMissing02()
+        {
+            ILRuntimeTest.TestFramework.TestCLRBinding binding = new ILRuntimeTest.TestFramework.TestCLRBinding();
+            binding.MissingMethodGeneric<TestCls2>(null);
+        }
+
+        [ILRuntimeTest.ILRuntimeTest(ExpectException = typeof(ILRuntimeException))]
+        public static void CLRBindingTestMissing03()
+        {
+            ILRuntimeTest.TestFramework.TestCLRBinding binding = new ILRuntimeTest.TestFramework.TestCLRBinding();
+            binding.missingField = 123;
+        }
+
+        [ILRuntimeTest.ILRuntimeTest(ExpectException = typeof(ILRuntimeException))]
+        public static void CLRBindingTestMissing04()
+        {
+            ILRuntimeTest.TestFramework.TestCLRBinding binding = new ILRuntimeTest.TestFramework.TestCLRBinding();
+            binding.Emit<MissingType>(null);
+        }
+
+        [ILRuntimeTest.ILRuntimeTest(ExpectException = typeof(ILRuntimeException))]
+        public static void CLRBindingTestMissing05()
+        {
+            ILRuntimeTest.TestFramework.TestCLRBinding binding = new ILRuntimeTest.TestFramework.TestCLRBinding();
+            binding.MissingMethodGeneric<MissingType>(null);
+        }
+
+        [ILRuntimeTest.ILRuntimeTest(ExpectException = typeof(ILRuntimeException))]
+        public static void CLRBindingTestMissing08()
+        {
+            MissingType mt = new MissingType();
+            
+        }
     }
 }