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; }