[mono][wasm] Allow AOTing methods with catch/filter clauses. (#64867)

* [mono][wasm] Allow AOTing methods with catch clauses.

This works as follows:
* During EH, when a catch clause is found in an AOTed method, the
  EH state is saved into TLS and a c++ exception is thrown.
* The C++ exception is caught by the AOTed method, and the landing
  pad code calls mono_llvm_resume_exception_il_state ().
* That call will run the catch clause and the rest of the method
  code using the interpreter, storing the possible return value
  back into the AOTed method's stack frame.
* After the call, the method skips the rest of its code, and
  returns immediately to its caller.

* Fix console bench sample.

* Fix landing pads.

* Fix issues.

* Add support for filter clauses.

* Implement all wasm return conventions.

* Fix arg/local write back.

* Avoid throwing a c++ exception from do_jit_call () so the caller can clean up the interpreter stack.

* Disable AOTing some more assemblies on CI.

* Rename llvmonly EH functions to mini_llvmonly_ for clarity.

* Improve unwinding through interpreter frames.

Instead of throwing a c++ exception from mono_handle_exception ()
when an exception is caught in AOTed code, set context->has_resume_state,
so the intepreter will normally unwind until exiting interpreted code.
Then throw the c++ exception after the call to interp_exec_method ()
to unwind through the runtime code and the AOTed frames
which can't handle the exception.

Author: vargaz

src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/System.Text.Json.SourceGeneration.Roslyn3.11.Tests.csproj

@@ -2,6 +2,10 @@
 
   <Import Project="System.Text.Json.SourceGeneration.Tests.targets" />
 
+  <ItemGroup Condition="'$(ContinuousIntegrationBuild)' == 'true'">
+    <HighAotMemoryUsageAssembly Include="System.Text.Json.SourceGeneration.Roslyn3.11.Tests.dll"/>
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\..\gen\System.Text.Json.SourceGeneration.Roslyn3.11.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
     <ProjectReference Include="..\System.Text.Json.SourceGeneration.TestLibrary\System.Text.Json.TestLibrary.Roslyn3.11.csproj" />

src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/System.Text.Json.SourceGeneration.Roslyn4.0.Tests.csproj

@@ -1,7 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <ItemGroup>
+  <ItemGroup Condition="'$(ContinuousIntegrationBuild)' == 'true'">
     <HighAotMemoryUsageAssembly Include="Microsoft.CodeAnalysis.CSharp.dll" />
+    <HighAotMemoryUsageAssembly Include="System.Text.Json.SourceGeneration.Roslyn4.0.Tests.dll"/>
   </ItemGroup>
 
   <Import Project="System.Text.Json.SourceGeneration.Tests.targets" />

src/libraries/System.Text.Json/tests/System.Text.Json.Tests/System.Text.Json.Tests.csproj

@@ -17,6 +17,11 @@
   <PropertyGroup>
     <DefineConstants Condition="$([MSBuild]::GetTargetFrameworkIdentifier('$(TargetFramework)')) == '.NETCoreApp'">$(DefineConstants);BUILDING_INBOX_LIBRARY</DefineConstants>
   </PropertyGroup>
+
+  <ItemGroup Condition="'$(ContinuousIntegrationBuild)' == 'true'">
+    <HighAotMemoryUsageAssembly Include="System.Text.Json.Tests.dll"/>
+  </ItemGroup>
+
   <ItemGroup>
     <Compile Include="$(CommonTestPath)System\IO\WrappedMemoryStream.cs" Link="CommonTest\System\IO\WrappedMemoryStream.cs" />
     <Compile Include="..\Common\CollectionTests\CollectionTests.AsyncEnumerable.cs" Link="CommonTest\System\Text\Json\Tests\Serialization\CollectionTests\CollectionTests.AsyncEnumerable.cs" />

src/mono/mono/metadata/jit-icall-reg.h

@@ -142,6 +142,14 @@ MONO_JIT_ICALL (mini_llvmonly_throw_nullref_exception) \
 MONO_JIT_ICALL (mini_llvmonly_throw_aot_failed_exception) \
 MONO_JIT_ICALL (mini_llvmonly_pop_lmf) \
 MONO_JIT_ICALL (mini_llvmonly_interp_entry_gsharedvt) \
+MONO_JIT_ICALL (mini_llvmonly_throw_exception) \
+MONO_JIT_ICALL (mini_llvmonly_rethrow_exception) \
+MONO_JIT_ICALL (mini_llvmonly_throw_corlib_exception) \
+MONO_JIT_ICALL (mini_llvmonly_resume_exception) \
+MONO_JIT_ICALL (mini_llvmonly_resume_exception_il_state) \
+MONO_JIT_ICALL (mini_llvmonly_load_exception) \
+MONO_JIT_ICALL (mini_llvmonly_clear_exception) \
+MONO_JIT_ICALL (mini_llvmonly_match_exception) \
 MONO_JIT_ICALL (mono_amd64_resume_unwind)	\
 MONO_JIT_ICALL (mono_amd64_start_gsharedvt_call)	\
 MONO_JIT_ICALL (mono_amd64_throw_corlib_exception)	\
@@ -220,18 +228,11 @@ MONO_JIT_ICALL (mono_ldtoken_wrapper) \
 MONO_JIT_ICALL (mono_ldtoken_wrapper_generic_shared) \
 MONO_JIT_ICALL (mono_ldvirtfn) \
 MONO_JIT_ICALL (mono_ldvirtfn_gshared) \
-MONO_JIT_ICALL (mono_llvm_clear_exception) \
-MONO_JIT_ICALL (mono_llvm_load_exception) \
-MONO_JIT_ICALL (mono_llvm_match_exception) \
-MONO_JIT_ICALL (mono_llvm_resume_exception) \
 MONO_JIT_ICALL (mono_llvm_resume_unwind_trampoline) \
-MONO_JIT_ICALL (mono_llvm_rethrow_exception) \
 MONO_JIT_ICALL (mono_llvm_rethrow_exception_trampoline) \
 MONO_JIT_ICALL (mono_llvm_set_unhandled_exception_handler) \
-MONO_JIT_ICALL (mono_llvm_throw_corlib_exception) \
 MONO_JIT_ICALL (mono_llvm_throw_corlib_exception_abs_trampoline) \
 MONO_JIT_ICALL (mono_llvm_throw_corlib_exception_trampoline) \
-MONO_JIT_ICALL (mono_llvm_throw_exception) \
 MONO_JIT_ICALL (mono_llvm_throw_exception_trampoline) \
 MONO_JIT_ICALL (mono_llvmonly_init_delegate) \
 MONO_JIT_ICALL (mono_llvmonly_init_delegate_virtual) \

src/mono/mono/mini/aot-compiler.c

@@ -13468,7 +13468,7 @@ static void aot_dump (MonoAotCompile *acfg)
 static const MonoJitICallId preinited_jit_icalls [] = {
 	MONO_JIT_ICALL_mini_llvm_init_method,
 	MONO_JIT_ICALL_mini_llvmonly_throw_nullref_exception,
-	MONO_JIT_ICALL_mono_llvm_throw_corlib_exception,
+	MONO_JIT_ICALL_mini_llvmonly_throw_corlib_exception,
 	MONO_JIT_ICALL_mono_threads_state_poll,
 	MONO_JIT_ICALL_mini_llvmonly_init_vtable_slot,
 	MONO_JIT_ICALL_mono_helper_ldstr_mscorlib,

src/mono/mono/mini/ee.h

@@ -14,7 +14,7 @@
 #ifndef __MONO_EE_H__
 #define __MONO_EE_H__
 
-#define MONO_EE_API_VERSION 0x15
+#define MONO_EE_API_VERSION 0x16
 
 typedef struct _MonoInterpStackIter MonoInterpStackIter;
 
@@ -38,7 +38,7 @@ typedef gpointer MonoInterpFrameHandle;
 	MONO_EE_CALLBACK (void, get_resume_state, (const MonoJitTlsData *jit_tls, gboolean *has_resume_state, MonoInterpFrameHandle *interp_frame, gpointer *handler_ip)) \
 	MONO_EE_CALLBACK (gboolean, run_finally, (StackFrameInfo *frame, int clause_index, gpointer handler_ip, gpointer handler_ip_end)) \
 	MONO_EE_CALLBACK (gboolean, run_filter, (StackFrameInfo *frame, MonoException *ex, int clause_index, gpointer handler_ip, gpointer handler_ip_end)) \
-	MONO_EE_CALLBACK (gboolean, run_finally_with_il_state, (gpointer il_state, int clause_index, gpointer handler_ip, gpointer handler_ip_end)) \
+	MONO_EE_CALLBACK (gboolean, run_clause_with_il_state, (gpointer il_state, int clause_index, gpointer handler_ip, gpointer handler_ip_end, MonoObject *ex, gboolean *filtered, MonoExceptionEnum clause_type)) \
 	MONO_EE_CALLBACK (void, frame_iter_init, (MonoInterpStackIter *iter, gpointer interp_exit_data)) \
 	MONO_EE_CALLBACK (gboolean, frame_iter_next, (MonoInterpStackIter *iter, StackFrameInfo *frame)) \
 	MONO_EE_CALLBACK (MonoJitInfo*, find_jit_info, (MonoMethod *method)) \

src/mono/mono/mini/interp-stubs.c

@@ -115,7 +115,8 @@ stub_run_filter (StackFrameInfo *frame, MonoException *ex, int clause_index, gpo
 }
 
 static gboolean
-stub_run_finally_with_il_state (gpointer il_state, int clause_index, gpointer handler_ip, gpointer handler_ip_end)
+stub_run_clause_with_il_state (gpointer il_state, int clause_index, gpointer handler_ip, gpointer handler_ip_end, MonoObject *ex,
+							   gboolean *filtered, MonoExceptionEnum clause_type)
 {
 	g_assert_not_reached ();
 }

src/mono/mono/mini/interp/interp-internals.h

@@ -210,6 +210,7 @@ typedef struct {
 	/* Lets interpreter know it has to resume execution after EH */
 	gboolean has_resume_state;
 	/* Frame to resume execution at */
+	/* Can be NULL if the exception is caught in an AOTed frame */
 	InterpFrame *handler_frame;
 	/* IP to resume execution at */
 	const guint16 *handler_ip;

src/mono/mono/mini/interp/interp.c

@@ -92,8 +92,6 @@ struct FrameClauseArgs {
 	 * frame further down the stack.
 	 */
 	const guint16 *end_at_ip;
-	/* When exiting this clause we also exit the frame */
-	int exit_clause;
 	/* Frame that is executing this clause */
 	InterpFrame *exec_frame;
 };
@@ -429,6 +427,14 @@ interp_free_context (gpointer ctx)
 	g_free (context);
 }
 
+/* Continue unwinding if there is an exception that needs to be handled in an AOTed frame above us */
+static void
+check_pending_unwind (ThreadContext *context)
+{
+	if (context->has_resume_state && !context->handler_frame)
+		mono_llvm_cpp_throw_exception ();
+}
+
 void
 mono_interp_error_cleanup (MonoError* error)
 {
@@ -2118,6 +2124,8 @@ interp_runtime_invoke (MonoMethod *method, void *obj, void **params, MonoObject
 
 	context->stack_pointer = (guchar*)sp;
 
+	check_pending_unwind (context);
+
 	if (context->has_resume_state) {
 		/*
 		 * This can happen on wasm where native frames cannot be skipped during EH.
@@ -2220,10 +2228,12 @@ interp_entry (InterpEntryData *data)
 	if (rmethod->needs_thread_attach)
 		mono_threads_detach_coop (orig_domain, &attach_cookie);
 
+	check_pending_unwind (context);
+
 	if (mono_llvm_only) {
 		if (context->has_resume_state)
 			/* The exception will be handled in a frame above us */
-			mono_llvm_reraise_exception ((MonoException*)mono_gchandle_get_target_internal (context->exc_gchandle));
+			mono_llvm_cpp_throw_exception ();
 	} else {
 		g_assert (!context->has_resume_state);
 	}
@@ -2641,9 +2651,20 @@ do_jit_call (ThreadContext *context, stackval *ret_sp, stackval *sp, InterpFrame
 			 * This happens when interp_entry calls mono_llvm_reraise_exception ().
 			 */
 			return;
-		MonoObject *obj = mono_llvm_load_exception ();
+		MonoJitTlsData *jit_tls = mono_get_jit_tls ();
+		if (jit_tls->resume_state.il_state) {
+			/*
+			 * This c++ exception is going to be caught by an AOTed frame above us.
+			 * We can't rethrow here, since that will skip the cleanup of the
+			 * interpreter stack space etc. So instruct the interpreter to unwind.
+			 */
+			context->has_resume_state = TRUE;
+			context->handler_frame = NULL;
+			return;
+		}
+		MonoObject *obj = mini_llvmonly_load_exception ();
 		g_assert (obj);
-		mono_llvm_clear_exception ();
+		mini_llvmonly_clear_exception ();
 		mono_error_set_exception_instance (error, (MonoException*)obj);
 		return;
 	}
@@ -2958,6 +2979,8 @@ interp_entry_from_trampoline (gpointer ccontext_untyped, gpointer rmethod_untype
 	if (rmethod->needs_thread_attach)
 		mono_threads_detach_coop (orig_domain, &attach_cookie);
 
+	check_pending_unwind (context);
+
 	/* Write back the return value */
 	/* 'frame' is still valid */
 	mono_arch_set_native_call_context_ret (ccontext, &frame, sig, retp);
@@ -2996,8 +3019,10 @@ interp_compile_interp_method (MonoMethod *method, MonoError *error)
 	InterpMethod *imethod = mono_interp_get_imethod (method, error);
 	return_val_if_nok (error, NULL);
 
-	mono_interp_transform_method (imethod, get_context (), error);
-	return_val_if_nok (error, NULL);
+	if (!imethod->transformed) {
+		mono_interp_transform_method (imethod, get_context (), error);
+		return_val_if_nok (error, NULL);
+	}
 
 	return imethod->jinfo;
 }
@@ -7269,6 +7294,8 @@ interp_parse_options (const char *options)
  * interp_set_resume_state:
  *
  *   Set the state the interpeter will continue to execute from after execution returns to the interpreter.
+ * If INTERP_FRAME is NULL, that means the exception is caught in an AOTed frame and the interpreter needs to
+ * unwind back to AOT code.
  */
 static void
 interp_set_resume_state (MonoJitTlsData *jit_tls, MonoObject *ex, MonoJitExceptionInfo *ei, MonoInterpFrameHandle interp_frame, gpointer handler_ip)
@@ -7286,8 +7313,10 @@ interp_set_resume_state (MonoJitTlsData *jit_tls, MonoObject *ex, MonoJitExcepti
 		mono_gchandle_free_internal (context->exc_gchandle);
 	context->exc_gchandle = mono_gchandle_new_internal ((MonoObject*)ex, FALSE);
 	/* Ditto */
-	if (ei)
-		*(MonoObject**)(frame_locals (context->handler_frame) + ei->exvar_offset) = ex;
+	if (context->handler_frame) {
+		if (ei)
+			*(MonoObject**)(frame_locals (context->handler_frame) + ei->exvar_offset) = ex;
+	}
 	context->handler_ip = (const guint16*)handler_ip;
 }
 
@@ -7323,7 +7352,6 @@ interp_run_finally (StackFrameInfo *frame, int clause_index, gpointer handler_ip
 	memset (&clause_args, 0, sizeof (FrameClauseArgs));
 	clause_args.start_with_ip = (const guint16*)handler_ip;
 	clause_args.end_at_ip = (const guint16*)handler_ip_end;
-	clause_args.exit_clause = clause_index;
 	clause_args.exec_frame = iframe;
 
 	state_ip = iframe->state.ip;
@@ -7339,6 +7367,9 @@ interp_run_finally (StackFrameInfo *frame, int clause_index, gpointer handler_ip
 
 	iframe->next_free = next_free;
 	iframe->state.ip = state_ip;
+
+	check_pending_unwind (context);
+
 	if (context->has_resume_state) {
 		return TRUE;
 	} else {
@@ -7390,32 +7421,41 @@ interp_run_filter (StackFrameInfo *frame, MonoException *ex, int clause_index, g
 
 	context->stack_pointer = (guchar*)child_frame.stack;
 
+	check_pending_unwind (context);
+
 	/* ENDFILTER stores the result into child_frame->retval */
 	return retval.data.i ? TRUE : FALSE;
 }
 
+/* Returns TRUE if there is a pending exception */
 static gboolean
-interp_run_finally_with_il_state (gpointer il_state_ptr, int clause_index, gpointer handler_ip, gpointer handler_ip_end)
+interp_run_clause_with_il_state (gpointer il_state_ptr, int clause_index, gpointer handler_ip, gpointer handler_ip_end,
+								 MonoObject *ex, gboolean *filtered, MonoExceptionEnum clause_type)
 {
 	MonoMethodILState *il_state = (MonoMethodILState*)il_state_ptr;
 	MonoMethodSignature *sig;
 	ThreadContext *context = get_context ();
+	stackval *orig_sp;
 	stackval *sp, *sp_args;
 	InterpMethod *imethod;
 	FrameClauseArgs clause_args;
 	ERROR_DECL (error);
 
-	// FIXME: Optimize this ? Its only used during EH
-
 	sig = mono_method_signature_internal (il_state->method);
 	g_assert (sig);
 
 	imethod = mono_interp_get_imethod (il_state->method, error);
 	mono_error_assert_ok (error);
 
-	sp_args = sp = (stackval*)context->stack_pointer;
+	orig_sp = sp_args = sp = (stackval*)context->stack_pointer;
+
+	gpointer ret_addr = NULL;
 
 	int findex = 0;
+	if (sig->ret->type != MONO_TYPE_VOID) {
+		ret_addr = il_state->data [findex];
+		findex ++;
+	}
 	if (sig->hasthis) {
 		if (il_state->data [findex])
 			sp_args->data.p = *(gpointer*)il_state->data [findex];
@@ -7451,32 +7491,41 @@ interp_run_finally_with_il_state (gpointer il_state_ptr, int clause_index, gpoin
 	if (header->num_locals)
 		memset (frame_locals (&frame) + imethod->local_offsets [0], 0, imethod->locals_size);
 	/* Copy locals from il_state */
-	int locals_start = sig->hasthis + sig->param_count;
+	int locals_start = findex;
 	for (int i = 0; i < header->num_locals; ++i) {
 		if (il_state->data [locals_start + i])
 			stackval_from_data (header->locals [i], (stackval*)(frame_locals (&frame) + imethod->local_offsets [i]), il_state->data [locals_start + i], FALSE);
 	}
 
 	memset (&clause_args, 0, sizeof (FrameClauseArgs));
 	clause_args.start_with_ip = (const guint16*)handler_ip;
-	clause_args.end_at_ip = (const guint16*)handler_ip_end;
-	clause_args.exit_clause = clause_index;
+	if (clause_type == MONO_EXCEPTION_CLAUSE_NONE || clause_type == MONO_EXCEPTION_CLAUSE_FILTER)
+		clause_args.end_at_ip = (const guint16*)clause_args.start_with_ip + 0xffffff;
+	else
+		clause_args.end_at_ip = (const guint16*)handler_ip_end;
 	clause_args.exec_frame = &frame;
 
-	// this informs MINT_ENDFINALLY to return to EH
-	*(guint16**)(frame_locals (&frame) + imethod->clause_data_offsets [clause_index]) = NULL;
+	if (clause_type == MONO_EXCEPTION_CLAUSE_NONE || clause_type == MONO_EXCEPTION_CLAUSE_FILTER)
+		*(MonoObject**)(frame_locals (&frame) + imethod->jinfo->clauses [clause_index].exvar_offset) = ex;
+	else
+		// this informs MINT_ENDFINALLY to return to EH
+		*(guint16**)(frame_locals (&frame) + imethod->clause_data_offsets [clause_index]) = NULL;
+
+	/* Set in mono_handle_exception () */
+	context->has_resume_state = FALSE;
 
 	interp_exec_method (&frame, context, &clause_args);
 
 	/* Write back args */
 	sp_args = sp;
 	findex = 0;
+	if (sig->ret->type != MONO_TYPE_VOID)
+		findex ++;
 	if (sig->hasthis) {
 		// FIXME: This
 		sp_args++;
 		findex ++;
 	}
-	findex = sig->hasthis ? 1 : 0;
 	for (int i = 0; i < sig->param_count; ++i) {
 		if (il_state->data [findex]) {
 			int size = stackval_to_data (sig->params [i], sp_args, il_state->data [findex], FALSE);
@@ -7494,11 +7543,19 @@ interp_run_finally_with_il_state (gpointer il_state_ptr, int clause_index, gpoin
 	}
 	mono_metadata_free_mh (header);
 
-	// FIXME: Restore stack ?
-	if (context->has_resume_state)
-		return TRUE;
-	else
-		return FALSE;
+	if (clause_type == MONO_EXCEPTION_CLAUSE_NONE && ret_addr) {
+		stackval_to_data (sig->ret, frame.retval, ret_addr, FALSE);
+	} else if (clause_type == MONO_EXCEPTION_CLAUSE_FILTER) {
+		g_assert (filtered);
+		*filtered = frame.retval->data.i;
+	}
+
+	memset (orig_sp, 0, (guint8*)context->stack_pointer - (guint8*)orig_sp);
+	context->stack_pointer = (guchar*)orig_sp;
+
+	check_pending_unwind (context);
+
+	return context->has_resume_state;
 }
 
 typedef struct {