static MonoException*
continuation_restore (MonoContinuation *cont, int state)
{
MonoLMF **lmf_addr = mono_get_lmf_addr ();
MonoContinuationRestore restore_state = mono_tasklets_arch_restore ();
if (!cont->domain || !cont->return_sp)
return mono_get_exception_argument ("cont", "Continuation not initialized");
if (cont->domain != mono_domain_get () || cont->thread_id != GetCurrentThreadId ())
return mono_get_exception_argument ("cont", "Continuation from another thread or domain");
/*g_print ("restore: %p, state: %d\n", cont, state);*/
*lmf_addr = cont->lmf;
restore_state (cont, state, lmf_addr);
g_assert_not_reached ();
}
static int
continuation_store (MonoContinuation *cont, int state, MonoException **e)
{
MonoLMF *lmf = mono_get_lmf ();
gsize num_bytes;
if (!cont->domain) {
*e = mono_get_exception_argument ("cont", "Continuation not initialized");
return 0;
}
if (cont->domain != mono_domain_get () || cont->thread_id != GetCurrentThreadId ()) {
*e = mono_get_exception_argument ("cont", "Continuation from another thread or domain");
return 0;
}
cont->lmf = lmf;
cont->return_ip = __builtin_return_address (0);
cont->return_sp = __builtin_frame_address (0);
num_bytes = (char*)cont->top_sp - (char*)cont->return_sp;
/*g_print ("store: %d bytes, sp: %p, ip: %p, lmf: %p\n", num_bytes, cont->return_sp, cont->return_ip, lmf);*/
if (cont->saved_stack && num_bytes <= cont->stack_alloc_size) {
/* clear to avoid GC retention */
if (num_bytes < cont->stack_used_size) {
memset ((char*)cont->saved_stack + num_bytes, 0, cont->stack_used_size - num_bytes);
}
cont->stack_used_size = num_bytes;
} else {
tasklets_lock ();
internal_init ();
if (cont->saved_stack) {
mono_g_hash_table_remove (keepalive_stacks, cont->saved_stack);
mono_gc_free_fixed (cont->saved_stack);
}
cont->stack_used_size = num_bytes;
cont->stack_alloc_size = num_bytes * 1.1;
cont->saved_stack = mono_gc_alloc_fixed (cont->stack_alloc_size, NULL);
mono_g_hash_table_insert (keepalive_stacks, cont->saved_stack, cont->saved_stack);
tasklets_unlock ();
}
memcpy (cont->saved_stack, cont->return_sp, num_bytes);
return state;
}
void godot_icall_Dictionary_Add(Dictionary *ptr, MonoObject *key, MonoObject *value) {
Variant varKey = GDMonoMarshal::mono_object_to_variant(key);
Variant *ret = ptr->getptr(varKey);
if (ret != NULL) {
GDMonoUtils::set_pending_exception(mono_get_exception_argument("key", "An element with the same key already exists"));
return;
}
ptr->operator[](varKey) = GDMonoMarshal::mono_object_to_variant(value);
}
static int
continuation_store (MonoContinuation *cont, int state, MonoException **e)
{
MonoLMF *lmf = mono_get_lmf ();
gsize num_bytes;
if (!cont->domain) {
*e = mono_get_exception_argument ("cont", "Continuation not initialized");
return 0;
}
if (cont->domain != mono_domain_get () || !mono_native_thread_id_equals (cont->thread_id, mono_native_thread_id_get ())) {
*e = mono_get_exception_argument ("cont", "Continuation from another thread or domain");
return 0;
}
cont->lmf = lmf;
cont->return_ip = __builtin_extract_return_addr (__builtin_return_address (0));
cont->return_sp = __builtin_frame_address (0);
num_bytes = (char*)cont->top_sp - (char*)cont->return_sp;
/*g_print ("store: %d bytes, sp: %p, ip: %p, lmf: %p\n", num_bytes, cont->return_sp, cont->return_ip, lmf);*/
if (cont->saved_stack && num_bytes <= cont->stack_alloc_size) {
/* clear to avoid GC retention */
if (num_bytes < cont->stack_used_size) {
memset ((char*)cont->saved_stack + num_bytes, 0, cont->stack_used_size - num_bytes);
}
cont->stack_used_size = num_bytes;
} else {
tasklets_lock ();
internal_init ();
if (cont->saved_stack)
mono_gc_free_fixed (cont->saved_stack);
cont->stack_used_size = num_bytes;
cont->stack_alloc_size = num_bytes * 1.1;
cont->saved_stack = mono_gc_alloc_fixed (cont->stack_alloc_size, NULL, MONO_ROOT_SOURCE_THREADING, "saved tasklet stack");
tasklets_unlock ();
}
memcpy (cont->saved_stack, cont->return_sp, num_bytes);
return state;
}
void godot_icall_Array_CopyTo(Array *ptr, MonoArray *array, int array_index) {
int count = ptr->size();
if (mono_array_length(array) < (array_index + count)) {
MonoException *exc = mono_get_exception_argument("", "Destination array was not long enough. Check destIndex and length, and the array's lower bounds.");
GDMonoUtils::set_pending_exception(exc);
return;
}
for (int i = 0; i < count; i++) {
MonoObject *boxed = GDMonoMarshal::variant_to_mono_object(ptr->operator[](i));
mono_array_setref(array, array_index, boxed);
array_index++;
}
}
static MonoException*
continuation_mark_frame (MonoContinuation *cont)
{
MonoJitTlsData *jit_tls;
MonoLMF *lmf;
MonoContext ctx, new_ctx;
MonoJitInfo *ji, rji;
int endloop = FALSE;
if (cont->domain)
return mono_get_exception_argument ("cont", "Already marked");
jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
lmf = mono_get_lmf();
cont->domain = mono_domain_get ();
cont->thread_id = mono_native_thread_id_get ();
/* get to the frame that called Mark () */
memset (&rji, 0, sizeof (rji));
memset (&ctx, 0, sizeof (ctx));
do {
ji = mono_find_jit_info (cont->domain, jit_tls, &rji, NULL, &ctx, &new_ctx, NULL, &lmf, NULL, NULL);
if (!ji || ji == (gpointer)-1) {
return mono_get_exception_not_supported ("Invalid stack frame");
}
ctx = new_ctx;
if (endloop)
break;
if (!ji->is_trampoline && strcmp (jinfo_get_method (ji)->name, "Mark") == 0)
endloop = TRUE;
} while (1);
cont->top_sp = MONO_CONTEXT_GET_SP (&ctx);
/*g_print ("method: %s, sp: %p\n", jinfo_get_method (ji)->name, cont->top_sp);*/
return NULL;
}
/*Can fail with out-of-memory*/
MonoException*
mono_error_prepare_exception (MonoError *oerror, MonoError *error_out)
{
MonoErrorInternal *error = (MonoErrorInternal*)oerror;
MonoException* exception = NULL;
MonoString *assembly_name = NULL, *type_name = NULL, *method_name = NULL, *field_name = NULL, *msg = NULL;
MonoDomain *domain = mono_domain_get ();
mono_error_init (error_out);
switch (error->error_code) {
case MONO_ERROR_NONE:
return NULL;
case MONO_ERROR_MISSING_METHOD:
if ((error->type_name || error->exn.klass) && error->member_name) {
type_name = get_type_name_as_mono_string (error, domain, error_out);
if (!mono_error_ok (error_out))
break;
method_name = mono_string_new (domain, error->member_name);
if (!method_name) {
mono_error_set_out_of_memory (error_out, "Could not allocate method name");
break;
}
exception = mono_exception_from_name_two_strings_checked (mono_defaults.corlib, "System", "MissingMethodException", type_name, method_name, error_out);
if (exception)
set_message_on_exception (exception, error, error_out);
} else {
exception = mono_exception_from_name_msg (mono_defaults.corlib, "System", "MissingMethodException", error->full_message);
}
break;
case MONO_ERROR_MISSING_FIELD:
if ((error->type_name || error->exn.klass) && error->member_name) {
type_name = get_type_name_as_mono_string (error, domain, error_out);
if (!mono_error_ok (error_out))
break;
field_name = mono_string_new (domain, error->member_name);
if (!field_name) {
mono_error_set_out_of_memory (error_out, "Could not allocate field name");
break;
}
exception = mono_exception_from_name_two_strings_checked (mono_defaults.corlib, "System", "MissingFieldException", type_name, field_name, error_out);
if (exception)
set_message_on_exception (exception, error, error_out);
} else {
exception = mono_exception_from_name_msg (mono_defaults.corlib, "System", "MissingFieldException", error->full_message);
}
break;
case MONO_ERROR_TYPE_LOAD:
if ((error->type_name && error->assembly_name) || error->exn.klass) {
type_name = get_type_name_as_mono_string (error, domain, error_out);
if (!mono_error_ok (error_out))
break;
if (error->assembly_name) {
assembly_name = mono_string_new (domain, error->assembly_name);
if (!assembly_name) {
mono_error_set_out_of_memory (error_out, "Could not allocate assembly name");
break;
}
}
exception = mono_exception_from_name_two_strings_checked (mono_get_corlib (), "System", "TypeLoadException", type_name, assembly_name, error_out);
if (exception)
set_message_on_exception (exception, error, error_out);
} else {
exception = mono_exception_from_name_msg (mono_defaults.corlib, "System", "TypeLoadException", error->full_message);
}
break;
case MONO_ERROR_FILE_NOT_FOUND:
case MONO_ERROR_BAD_IMAGE:
if (error->assembly_name) {
msg = mono_string_new (domain, error->full_message);
if (!msg) {
mono_error_set_out_of_memory (error_out, "Could not allocate message");
break;
}
if (error->assembly_name) {
assembly_name = mono_string_new (domain, error->assembly_name);
if (!assembly_name) {
mono_error_set_out_of_memory (error_out, "Could not allocate assembly name");
break;
}
}
if (error->error_code == MONO_ERROR_FILE_NOT_FOUND)
exception = mono_exception_from_name_two_strings_checked (mono_get_corlib (), "System.IO", "FileNotFoundException", msg, assembly_name, error_out);
else
exception = mono_exception_from_name_two_strings_checked (mono_defaults.corlib, "System", "BadImageFormatException", msg, assembly_name, error_out);
} else {
if (error->error_code == MONO_ERROR_FILE_NOT_FOUND)
exception = mono_exception_from_name_msg (mono_get_corlib (), "System.IO", "FileNotFoundException", error->full_message);
else
exception = mono_exception_from_name_msg (mono_defaults.corlib, "System", "BadImageFormatException", error->full_message);
}
break;
case MONO_ERROR_OUT_OF_MEMORY:
exception = mono_get_exception_out_of_memory ();
break;
case MONO_ERROR_ARGUMENT:
exception = mono_get_exception_argument (error->first_argument, error->full_message);
break;
case MONO_ERROR_ARGUMENT_NULL:
exception = mono_get_exception_argument_null (error->first_argument);
break;
case MONO_ERROR_NOT_VERIFIABLE: {
char *type_name = NULL, *message;
if (error->exn.klass) {
type_name = mono_type_get_full_name (error->exn.klass);
if (!type_name) {
mono_error_set_out_of_memory (error_out, "Could not allocate message");
break;
}
}
message = g_strdup_printf ("Error in %s:%s %s", type_name, error->member_name, error->full_message);
if (!message) {
g_free (type_name);
mono_error_set_out_of_memory (error_out, "Could not allocate message");
break;
}
exception = mono_exception_from_name_msg (mono_defaults.corlib, "System.Security", "VerificationException", message);
g_free (message);
g_free (type_name);
break;
}
case MONO_ERROR_GENERIC:
if (!error->exception_name_space || !error->exception_name)
mono_error_set_execution_engine (error_out, "MonoError with generic error but no exception name was supplied");
else
exception = mono_exception_from_name_msg (mono_defaults.corlib, error->exception_name_space, error->exception_name, error->full_message);
break;
case MONO_ERROR_EXCEPTION_INSTANCE:
exception = (MonoException*) mono_gchandle_get_target (error->exn.instance_handle);
break;
case MONO_ERROR_CLEANUP_CALLED_SENTINEL:
mono_error_set_execution_engine (error_out, "MonoError reused after mono_error_cleanup");
break;
case MONO_ERROR_INVALID_PROGRAM: {
gboolean lacks_message = error->flags & MONO_ERROR_INCOMPLETE;
if (lacks_message)
return mono_exception_from_name_msg (mono_defaults.corlib, "System", "InvalidProgramException", "");
else
return mono_exception_from_name_msg (mono_defaults.corlib, "System", "InvalidProgramException", error->full_message);
}
default:
mono_error_set_execution_engine (error_out, "Invalid error-code %d", error->error_code);
}
if (!mono_error_ok (error_out))
return NULL;
if (!exception)
mono_error_set_out_of_memory (error_out, "Could not allocate exception object");
return exception;
}
/*Can fail with out-of-memory*/
MonoException*
mono_error_prepare_exception (MonoError *oerror, MonoError *error_out)
{
MonoErrorInternal *error = (MonoErrorInternal*)oerror;
MonoException* exception = NULL;
MonoString *assembly_name = NULL, *type_name = NULL, *method_name = NULL, *field_name = NULL, *msg = NULL;
MonoDomain *domain = mono_domain_get ();
mono_error_init (error_out);
switch (error->error_code) {
case MONO_ERROR_NONE:
return NULL;
case MONO_ERROR_MISSING_METHOD:
if ((error->type_name || error->klass) && error->member_name) {
type_name = get_type_name_as_mono_string (error, domain, error_out);
if (!mono_error_ok (error_out))
break;
method_name = mono_string_new (domain, error->member_name);
if (!method_name) {
mono_error_set_out_of_memory (error_out, "Could not allocate method name");
break;
}
exception = mono_exception_from_name_two_strings (mono_defaults.corlib, "System", "MissingMethodException", type_name, method_name);
if (exception)
set_message_on_exception (exception, error, error_out);
} else {
exception = mono_exception_from_name_msg (mono_defaults.corlib, "System", "MissingMethodException", mono_internal_error_get_message (error));
}
break;
case MONO_ERROR_MISSING_FIELD:
if ((error->type_name || error->klass) && error->member_name) {
type_name = get_type_name_as_mono_string (error, domain, error_out);
if (!mono_error_ok (error_out))
break;
field_name = mono_string_new (domain, error->member_name);
if (!field_name) {
mono_error_set_out_of_memory (error_out, "Could not allocate field name");
break;
}
exception = mono_exception_from_name_two_strings (mono_defaults.corlib, "System", "MissingFieldException", type_name, field_name);
if (exception)
set_message_on_exception (exception, error, error_out);
} else {
exception = mono_exception_from_name_msg (mono_defaults.corlib, "System", "MissingFieldException", mono_internal_error_get_message (error));
}
break;
case MONO_ERROR_TYPE_LOAD:
if (error->type_name || error->assembly_name) {
type_name = get_type_name_as_mono_string (error, domain, error_out);
if (!mono_error_ok (error_out))
break;
if (error->assembly_name) {
assembly_name = mono_string_new (domain, error->assembly_name);
if (!assembly_name) {
mono_error_set_out_of_memory (error_out, "Could not allocate assembly name");
break;
}
}
exception = mono_exception_from_name_two_strings (mono_get_corlib (), "System", "TypeLoadException", type_name, assembly_name);
if (exception)
set_message_on_exception (exception, error, error_out);
} else {
exception = mono_exception_from_name_msg (mono_defaults.corlib, "System", "TypeLoadException", mono_internal_error_get_message (error));
}
break;
case MONO_ERROR_FILE_NOT_FOUND:
case MONO_ERROR_BAD_IMAGE:
if (error->assembly_name) {
msg = mono_string_new (domain, mono_internal_error_get_message (error));
if (!msg) {
mono_error_set_out_of_memory (error_out, "Could not allocate message");
break;
}
if (error->assembly_name) {
assembly_name = mono_string_new (domain, error->assembly_name);
if (!assembly_name) {
mono_error_set_out_of_memory (error_out, "Could not allocate assembly name");
break;
}
}
if (error->error_code == MONO_ERROR_FILE_NOT_FOUND)
exception = mono_exception_from_name_two_strings (mono_get_corlib (), "System.IO", "FileNotFoundException", msg, assembly_name);
else
exception = mono_exception_from_name_two_strings (mono_defaults.corlib, "System", "BadImageFormatException", msg, assembly_name);
} else {
if (error->error_code == MONO_ERROR_FILE_NOT_FOUND)
exception = mono_exception_from_name_msg (mono_get_corlib (), "System.IO", "FileNotFoundException", mono_internal_error_get_message (error));
else
exception = mono_exception_from_name_msg (mono_defaults.corlib, "System", "BadImageFormatException", mono_internal_error_get_message (error));
}
break;
case MONO_ERROR_OUT_OF_MEMORY:
exception = mono_get_exception_out_of_memory ();
break;
case MONO_ERROR_ARGUMENT:
exception = mono_get_exception_argument (error->type_name, mono_internal_error_get_message (error));
break;
case MONO_ERROR_NOT_VERIFIABLE: {
char *type_name = NULL, *message;
if (error->klass) {
type_name = mono_type_get_full_name (error->klass);
if (!type_name) {
mono_error_set_out_of_memory (error_out, "Could not allocate message");
break;
}
}
message = g_strdup_printf ("Error in %s:%s %s", type_name, error->member_name, mono_internal_error_get_message (error));
if (!message) {
g_free (type_name);
mono_error_set_out_of_memory (error_out, "Could not allocate message");
break;
}
exception = mono_exception_from_name_msg (mono_defaults.corlib, "System.Security", "VerificationException", message);
g_free (message);
g_free (type_name);
break;
}
case MONO_ERROR_GENERIC:
if (!error->exception_name_space || !error->exception_name)
mono_error_set_generic_error (error_out, "System", "ExecutionEngineException", "MonoError with generic error but no exception name was supplied");
else
exception = mono_exception_from_name_msg (mono_defaults.corlib, error->exception_name_space, error->exception_name, mono_internal_error_get_message (error));
break;
default:
mono_error_set_generic_error (error_out, "System", "ExecutionEngineException", "Invalid error-code %d", error->error_code);
}
if (!mono_error_ok (error_out))
return NULL;
if (!exception)
mono_error_set_out_of_memory (error_out, "Could not allocate exception object");
return exception;
}
