[runtime] Fix MonoError lifecycle in do_try_exec_main (#3145)

The do_try_exec_main function is always called in contexts where any
exception from doing the invoke is going to be stored in the exc outarg.
That means any MonoError will be handled locally by do_try_exec_main.
So we don't need a MonoError argument, we just need an inner_error.

diff --git a/mono/metadata/object-internals.h b/mono/metadata/object-internals.h
index ee0f6ab546ab55a4c933df452df3add21e567ed2..fb76fb8a72f53055f229ff31089b5021f0e33cfd 100644 (file)
--- a/mono/metadata/object-internals.h
+++ b/mono/metadata/object-internals.h
@@ -1746,13 +1746,13 @@ mono_runtime_run_main_checked (MonoMethod *method, int argc, char* argv[],
 
 int
 mono_runtime_try_run_main (MonoMethod *method, int argc, char* argv[],
-                          MonoObject **exc, MonoError *error);
+                          MonoObject **exc);
 
 int
 mono_runtime_exec_main_checked (MonoMethod *method, MonoArray *args, MonoError *error);
 
 int
-mono_runtime_try_exec_main (MonoMethod *method, MonoArray *args, MonoObject **exc, MonoError *error);
+mono_runtime_try_exec_main (MonoMethod *method, MonoArray *args, MonoObject **exc);
 
 
 #endif /* __MONO_OBJECT_INTERNALS_H__ */

diff --git a/mono/metadata/object.c b/mono/metadata/object.c
index c402b1d20552dfe9b32abfd3eaedcc588020eeaf..6d67358ec0784973a90d45d3cd1a9818e1b58d97 100644 (file)
--- a/mono/metadata/object.c
+++ b/mono/metadata/object.c
@@ -4289,11 +4289,7 @@ mono_runtime_run_main (MonoMethod *method, int argc, char* argv[],
        MonoArray *args = prepare_run_main (method, argc, argv);
        int res;
        if (exc) {
-               res = mono_runtime_try_exec_main (method, args, exc, &error);
-               if (*exc == NULL && !is_ok (&error))
-                       *exc = (MonoObject*) mono_error_convert_to_exception (&error);
-               else
-                       mono_error_cleanup (&error);
+               res = mono_runtime_try_exec_main (method, args, exc);
        } else {
                res = mono_runtime_exec_main_checked (method, args, &error);
                mono_error_raise_exception (&error); /* OK to throw, external only without a better alternative */
@@ -4340,12 +4336,11 @@ mono_runtime_run_main_checked (MonoMethod *method, int argc, char* argv[],
  */
 int
 mono_runtime_try_run_main (MonoMethod *method, int argc, char* argv[],
-                          MonoObject **exc, MonoError *error)
+                          MonoObject **exc)
 {
        g_assert (exc);
-       mono_error_init (error);
        MonoArray *args = prepare_run_main (method, argc, argv);
-       return mono_runtime_try_exec_main (method, args, exc, error);
+       return mono_runtime_try_exec_main (method, args, exc);
 }
 
 
@@ -4793,14 +4788,13 @@ do_exec_main_checked (MonoMethod *method, MonoArray *args, MonoError *error)
 }
 
 static int
-do_try_exec_main (MonoMethod *method, MonoArray *args, MonoObject **exc, MonoError *error)
+do_try_exec_main (MonoMethod *method, MonoArray *args, MonoObject **exc)
 {
        MONO_REQ_GC_UNSAFE_MODE;
 
        gpointer pa [1];
        int rval;
 
-       mono_error_init (error);
        g_assert (args);
        g_assert (exc);
 
@@ -4808,12 +4802,13 @@ do_try_exec_main (MonoMethod *method, MonoArray *args, MonoObject **exc, MonoErr
 
        /* FIXME: check signature of method */
        if (mono_method_signature (method)->ret->type == MONO_TYPE_I4) {
+               MonoError inner_error;
                MonoObject *res;
-               res = mono_runtime_try_invoke (method, NULL, pa, exc, error);
-               if (*exc == NULL && !mono_error_ok (error))
-                       *exc = (MonoObject*) mono_error_convert_to_exception (error);
+               res = mono_runtime_try_invoke (method, NULL, pa, exc, &inner_error);
+               if (*exc == NULL && !mono_error_ok (&inner_error))
+                       *exc = (MonoObject*) mono_error_convert_to_exception (&inner_error);
                else
-                       mono_error_cleanup (error);
+                       mono_error_cleanup (&inner_error);
 
                if (*exc == NULL)
                        rval = *(guint32 *)((char *)res + sizeof (MonoObject));
@@ -4822,11 +4817,12 @@ do_try_exec_main (MonoMethod *method, MonoArray *args, MonoObject **exc, MonoErr
 
                mono_environment_exitcode_set (rval);
        } else {
-               mono_runtime_try_invoke (method, NULL, pa, exc, error);
-               if (*exc == NULL && !mono_error_ok (error))
-                       *exc = (MonoObject*) mono_error_convert_to_exception (error);
+               MonoError inner_error;
+               mono_runtime_try_invoke (method, NULL, pa, exc, &inner_error);
+               if (*exc == NULL && !mono_error_ok (&inner_error))
+                       *exc = (MonoObject*) mono_error_convert_to_exception (&inner_error);
                else
-                       mono_error_cleanup (error);
+                       mono_error_cleanup (&inner_error);
 
                if (*exc == NULL)
                        rval = 0;
@@ -4854,11 +4850,7 @@ mono_runtime_exec_main (MonoMethod *method, MonoArray *args, MonoObject **exc)
        MonoError error;
        prepare_thread_to_exec_main (mono_object_domain (args), method);
        if (exc) {
-               int rval = do_try_exec_main (method, args, exc, &error);
-               if (*exc == NULL && !is_ok (&error))
-                       *exc = (MonoObject*) mono_error_convert_to_exception (&error);
-               else
-                       mono_error_cleanup (&error);
+               int rval = do_try_exec_main (method, args, exc);
                return rval;
        } else {
                int rval = do_exec_main_checked (method, args, &error);
@@ -4888,11 +4880,10 @@ mono_runtime_exec_main_checked (MonoMethod *method, MonoArray *args, MonoError *
  * On failure sets @error if Main couldn't be executed, or @exc if it threw an exception.
  */
 int
-mono_runtime_try_exec_main (MonoMethod *method, MonoArray *args, MonoObject **exc, MonoError *error)
+mono_runtime_try_exec_main (MonoMethod *method, MonoArray *args, MonoObject **exc)
 {
-       mono_error_init (error);
        prepare_thread_to_exec_main (mono_object_domain (args), method);
-       return do_try_exec_main (method, args, exc, error);
+       return do_try_exec_main (method, args, exc);
 }
 
 

diff --git a/mono/mini/driver.c b/mono/mini/driver.c
index 9835ccc6f08b2245239554a00de8408dd45c412f..18639e9de084d3b9c0d1b8edd2b88618bb964b99 100644 (file)
--- a/mono/mini/driver.c
+++ b/mono/mini/driver.c
@@ -1029,11 +1029,7 @@ mono_jit_exec (MonoDomain *domain, MonoAssembly *assembly, int argc, char *argv[
                MonoObject *exc = NULL;
                int res;
 
-               res = mono_runtime_try_run_main (method, argc, argv, &exc, &error);
-               if (exc == NULL && !is_ok (&error))
-                       exc = (MonoObject*) mono_error_convert_to_exception (&error);
-               else
-                       mono_error_cleanup (&error);
+               res = mono_runtime_try_run_main (method, argc, argv, &exc);
                if (exc) {
                        mono_unhandled_exception (exc);
                        mono_invoke_unhandled_exception_hook (exc);