/** * mono_exception_from_token: * \param image the Mono image where to look for the class * \param token The type token of the class * * Creates an exception of the type given by \p token. * * \returns the initialized exception instance. */ MonoException * mono_exception_from_token (MonoImage *image, guint32 token) { HANDLE_FUNCTION_ENTER (); ERROR_DECL (error); MonoClass *klass; klass = mono_class_get_checked (image, token, error); mono_error_assert_ok (error); MonoObjectHandle o = mono_object_new_handle (mono_domain_get (), klass, error); mono_error_assert_ok (error); mono_runtime_object_init_handle (o, error); mono_error_assert_ok (error); HANDLE_FUNCTION_RETURN_OBJ (MONO_HANDLE_CAST (MonoException, o)); }
/** * mono_exception_from_token: * @image: the Mono image where to look for the class * @token: The type token of the class * * Creates an exception of the type given by @token. * * Returns: the initialized exception instance. */ MonoException * mono_exception_from_token (MonoImage *image, guint32 token) { MonoError error; MonoClass *klass; MonoObject *o; klass = mono_class_get_checked (image, token, &error); mono_error_assert_ok (&error); o = mono_object_new_checked (mono_domain_get (), klass, &error); mono_error_assert_ok (&error); mono_runtime_object_init_checked (o, &error); mono_error_assert_ok (&error); return (MonoException *)o; }
/** * mono_get_exception_file_not_found: * @fname: the name of the file not found. * * Returns: a new instance of the `System.IO.FileNotFoundException` */ MonoException * mono_get_exception_file_not_found (MonoString *fname) { MonoError error; MonoException *ret = mono_exception_from_name_two_strings_checked ( mono_get_corlib (), "System.IO", "FileNotFoundException", fname, fname, &error); mono_error_assert_ok (&error); return ret; }
/** * mono_get_exception_bad_image_format2: * \param msg an informative message for the user. * \param fname The full name of the file with the invalid image. * \returns a new instance of the \c System.BadImageFormatException */ MonoException * mono_get_exception_bad_image_format2 (const char *msg, MonoString *fname_raw) { HANDLE_FUNCTION_ENTER (); ERROR_DECL (error); MonoStringHandle s = NULL_HANDLE_STRING; MONO_HANDLE_DCL (MonoString, fname); if (msg) { s = mono_string_new_handle (mono_domain_get (), msg, error); mono_error_assert_ok (error); } MonoExceptionHandle ret = mono_exception_from_name_two_strings_checked ( mono_get_corlib (), "System", "BadImageFormatException", s, fname, error); mono_error_assert_ok (error); HANDLE_FUNCTION_RETURN_OBJ (ret); }
/** * mono_get_exception_type_load: * \param class_name the name of the class that could not be loaded * \param assembly_name the assembly where the class was looked up. * \returns a new instance of the \c System.TypeLoadException */ MonoException * mono_get_exception_type_load (MonoString *class_name_raw, char *assembly_name) { ERROR_DECL (error); HANDLE_FUNCTION_ENTER (); MONO_HANDLE_DCL (MonoString, class_name); MonoStringHandle s = NULL_HANDLE_STRING; MonoDomain * const domain = mono_domain_get (); if (assembly_name) { s = mono_string_new_handle (domain, assembly_name, error); mono_error_assert_ok (error); } else s = mono_string_empty_handle (domain); MonoExceptionHandle ret = mono_exception_from_name_two_strings_checked (mono_get_corlib (), "System", "TypeLoadException", class_name, s, error); mono_error_assert_ok (error); HANDLE_FUNCTION_RETURN_OBJ (ret); }
/** * mono_get_exception_file_not_found: * \param fname the name of the file not found. * \returns a new instance of the \c System.IO.FileNotFoundException */ MonoException * mono_get_exception_file_not_found (MonoString *fname_raw) { HANDLE_FUNCTION_ENTER (); ERROR_DECL (error); MONO_HANDLE_DCL (MonoString, fname); MonoExceptionHandle ret = mono_exception_from_name_two_strings_checked (mono_get_corlib (), "System.IO", "FileNotFoundException", fname, fname, error); mono_error_assert_ok (error); HANDLE_FUNCTION_RETURN_OBJ (ret); }
static guint32 rand_next (gpointer *handle, guint32 min, guint32 max) { MonoError error; guint32 val; mono_rand_try_get_uint32 (handle, &val, min, max, &error); // FIXME handle error mono_error_assert_ok (&error); return val; }
/** * mono_exception_from_name_domain: * \param domain Domain where the return object will be created. * \param image the Mono image where to look for the class * \param name_space the namespace for the class * \param name class name * * Creates an exception object of the given namespace/name class on * the given domain. * * \returns the initialized exception instance. */ MonoException * mono_exception_from_name_domain (MonoDomain *domain, MonoImage *image, const char* name_space, const char *name) { HANDLE_FUNCTION_ENTER (); ERROR_DECL (error); MonoExceptionHandle ret = mono_exception_new_by_name_domain (domain, image, name_space, name, error); mono_error_assert_ok (error); HANDLE_FUNCTION_RETURN_OBJ (ret); }
MonoExceptionHandle mono_get_exception_type_initialization_handle (const gchar *type_name, MonoExceptionHandle inner, MonoError *error) { HANDLE_FUNCTION_ENTER (); MonoClass *klass; MonoMethod *method; gpointer iter; error_init (error); klass = mono_class_load_from_name (mono_get_corlib (), "System", "TypeInitializationException"); mono_class_init_internal (klass); iter = NULL; while ((method = mono_class_get_methods (klass, &iter))) { if (!strcmp (".ctor", mono_method_get_name (method))) { MonoMethodSignature *sig = mono_method_signature_internal (method); if (sig->param_count == 2 && sig->params [0]->type == MONO_TYPE_STRING && mono_class_from_mono_type_internal (sig->params [1]) == mono_defaults.exception_class) break; } method = NULL; } g_assert (method); MonoDomain * const domain = mono_domain_get (); MonoStringHandle type_name_str = mono_string_new_handle (domain, type_name, error); mono_error_assert_ok (error); gpointer args [ ] = { MONO_HANDLE_RAW (type_name_str), MONO_HANDLE_RAW (inner) }; MonoObjectHandle exc = mono_object_new_handle (domain, klass, error); mono_error_assert_ok (error); mono_runtime_invoke_handle (method, exc, args, error); goto_if_nok (error, return_null); goto exit; return_null: exc = mono_new_null (); exit: HANDLE_FUNCTION_RETURN_REF (MonoException, MONO_HANDLE_CAST (MonoException, exc)); }
/** * mono_get_exception_type_load: * @class_name: the name of the class that could not be loaded * @assembly_name: the assembly where the class was looked up. * * Returns: a new instance of the `System.TypeLoadException` */ MonoException * mono_get_exception_type_load (MonoString *class_name, char *assembly_name) { MonoString *s = assembly_name ? mono_string_new (mono_domain_get (), assembly_name) : mono_string_new (mono_domain_get (), ""); MonoError error; MonoException *ret = mono_exception_from_name_two_strings_checked (mono_get_corlib (), "System", "TypeLoadException", class_name, s, &error); mono_error_assert_ok (&error); return ret; }
/** * mono_get_exception_file_not_found2: * @msg: an informative message for the user. * @fname: the name of the file not found. * * Returns: a new instance of the `System.IO.FileNotFoundException` */ MonoException * mono_get_exception_file_not_found2 (const char *msg, MonoString *fname) { MonoString *s = msg ? mono_string_new (mono_domain_get (), msg) : NULL; MonoError error; MonoException *ret = mono_exception_from_name_two_strings_checked ( mono_get_corlib (), "System.IO", "FileNotFoundException", s, fname, &error); mono_error_assert_ok (&error); return ret; }
/** * mono_get_exception_bad_image_format2: * @msg: an informative message for the user. * @fname: The full name of the file with the invalid image. * * Returns: a new instance of the `System.BadImageFormatException` */ MonoException * mono_get_exception_bad_image_format2 (const char *msg, MonoString *fname) { MonoString *s = msg ? mono_string_new (mono_domain_get (), msg) : NULL; MonoError error; MonoException *ret = mono_exception_from_name_two_strings_checked ( mono_get_corlib (), "System", "BadImageFormatException", s, fname, &error); mono_error_assert_ok (&error); return ret; }
/** * mono_profiler_coverage_get: * @prof: The profiler handle, installed with mono_profiler_install * @method: the method to gather information from. * @func: A routine that will be called back with the results * * If the MONO_PROFILER_INS_COVERAGE flag was active during JIT compilation * it is posisble to obtain coverage information about a give method. * * The function @func will be invoked repeatedly with instances of the * MonoProfileCoverageEntry structure. */ void mono_profiler_coverage_get (MonoProfiler *prof, MonoMethod *method, MonoProfileCoverageFunc func) { MonoError error; MonoProfileCoverageInfo* info = NULL; int i, offset; guint32 code_size; const unsigned char *start, *end, *cil_code; MonoMethodHeader *header; MonoProfileCoverageEntry entry; MonoDebugMethodInfo *debug_minfo; mono_profiler_coverage_lock (); if (coverage_hash) info = (MonoProfileCoverageInfo *)g_hash_table_lookup (coverage_hash, method); mono_profiler_coverage_unlock (); if (!info) return; header = mono_method_get_header_checked (method, &error); mono_error_assert_ok (&error); start = mono_method_header_get_code (header, &code_size, NULL); debug_minfo = mono_debug_lookup_method (method); end = start + code_size; for (i = 0; i < info->entries; ++i) { cil_code = info->data [i].cil_code; if (cil_code && cil_code >= start && cil_code < end) { char *fname = NULL; offset = cil_code - start; entry.iloffset = offset; entry.method = method; entry.counter = info->data [i].count; entry.line = entry.col = 1; entry.filename = NULL; if (debug_minfo) { MonoDebugSourceLocation *location; location = mono_debug_symfile_lookup_location (debug_minfo, offset); if (location) { entry.line = location->row; entry.col = location->column; entry.filename = fname = g_strdup (location->source_file); mono_debug_free_source_location (location); } } func (prof, &entry); g_free (fname); } } mono_metadata_free_mh (header); }
/** * mono_get_exception_missing_field: * @class_name: the class where the lookup was performed * @member_name: the name of the missing method. * * Returns: a new instance of the `System.MissingFieldException` */ MonoException * mono_get_exception_missing_field (const char *class_name, const char *member_name) { MonoString *s1 = mono_string_new (mono_domain_get (), class_name); MonoString *s2 = mono_string_new (mono_domain_get (), member_name); MonoError error; MonoException *ret = mono_exception_from_name_two_strings_checked (mono_get_corlib (), "System", "MissingFieldException", s1, s2, &error); mono_error_assert_ok (&error); return ret; }
/** * mono_exception_from_token_two_strings_checked: * * Same as mono_exception_from_name_two_strings, but lookup the exception class using * IMAGE and TOKEN. */ MonoException * mono_exception_from_token_two_strings_checked (MonoImage *image, guint32 token, MonoString *a1, MonoString *a2, MonoError *error) { MonoClass *klass; mono_error_init (error); klass = mono_class_get_checked (image, token, error); mono_error_assert_ok (error); /* FIXME handle the error. */ return create_exception_two_strings (klass, a1, a2, error); }
/** * mono_exception_from_name_domain: * @domain: Domain where the return object will be created. * @image: the Mono image where to look for the class * @name_space: the namespace for the class * @name: class name * * Creates an exception object of the given namespace/name class on * the given domain. * * Returns: the initialized exception instance. */ MonoException * mono_exception_from_name_domain (MonoDomain *domain, MonoImage *image, const char* name_space, const char *name) { MonoError error; MonoClass *klass; MonoObject *o; MonoDomain *caller_domain = mono_domain_get (); klass = mono_class_load_from_name (image, name_space, name); o = mono_object_new_checked (domain, klass, &error); mono_error_assert_ok (&error); if (domain != caller_domain) mono_domain_set_internal (domain); mono_runtime_object_init_checked (o, &error); mono_error_assert_ok (&error); if (domain != caller_domain) mono_domain_set_internal (caller_domain); return (MonoException *)o; }
/** * mono_exception_from_token_two_strings: * * Same as mono_exception_from_name_two_strings, but lookup the exception class using * IMAGE and TOKEN. */ MonoException * mono_exception_from_token_two_strings (MonoImage *image, guint32 token, MonoString *a1, MonoString *a2) { MonoError error; MonoClass *klass; MonoException *ret; klass = mono_class_get_checked (image, token, &error); mono_error_assert_ok (&error); /* FIXME handle the error. */ ret = create_exception_two_strings (klass, a1, a2, &error); mono_error_raise_exception (&error); /* FIXME don't raise here */ return ret; }
/** * mono_exception_from_token_two_strings_checked: * * Same as mono_exception_from_name_two_strings, but lookup the exception class using * IMAGE and TOKEN. */ MonoExceptionHandle mono_exception_from_token_two_strings_checked (MonoImage *image, guint32 token, MonoStringHandle a1, MonoStringHandle a2, MonoError *error) { HANDLE_FUNCTION_ENTER (); MonoClass *klass; error_init (error); klass = mono_class_get_checked (image, token, error); mono_error_assert_ok (error); /* FIXME handle the error. */ HANDLE_FUNCTION_RETURN_REF (MonoException, create_exception_two_strings (klass, a1, a2, error)); }
static void mono_init_merp (const intptr_t crashed_pid, const char *signal, MonoStackHash *hashes, MERPStruct *merp, const char *version) { g_assert (mono_merp_enabled ()); // If these aren't set, icall wasn't made // don't do merp? / don't set the variable to use merp; g_assert (config.appBundleID); g_assert (config.appVersion); merp->bundleIDArg = config.appSignature; merp->versionArg = config.appVersion; merp->archArg = get_merp_arch (); merp->exceptionArg = parse_exception_type (signal); merp->serviceNameArg = config.appBundleID; // FIXME: Not really a posix way to associated a process with a single executable // path? Linux gets bogged down in /proc merp->servicePathArg = NULL; if (crashed_pid) { size_t servicePathSize = sizeof (gchar) * 1200; merp->servicePathArg = g_malloc0 (servicePathSize); int result = proc_pidpath (crashed_pid, (void *) merp->servicePathArg, 1200); if (result <= 0) { g_free ((void *) merp->servicePathArg); merp->servicePathArg = NULL; } } merp->moduleName = "Mono Exception"; merp->moduleVersion = version; merp->moduleOffset = 0; ERROR_DECL (error); merp->uiLidArg = ves_icall_System_Threading_Thread_current_lcid (error); mono_error_assert_ok (error); merp->osVersion = os_version_string (); // FIXME: THis is apple-only for now merp->systemManufacturer = "apple"; get_apple_model ((char *) merp->systemModel, sizeof (merp->systemModel)); merp->hashes = *hashes; }
static MonoException * create_exception_two_strings (MonoClass *klass, MonoString *a1, MonoString *a2) { MonoError error; MonoDomain *domain = mono_domain_get (); MonoMethod *method = NULL; MonoObject *o; int count = 1; gpointer args [2]; gpointer iter; MonoMethod *m; if (a2 != NULL) count++; o = mono_object_new_checked (domain, klass, &error); mono_error_assert_ok (&error); iter = NULL; while ((m = mono_class_get_methods (klass, &iter))) { MonoMethodSignature *sig; if (strcmp (".ctor", mono_method_get_name (m))) continue; sig = mono_method_signature (m); if (sig->param_count != count) continue; if (sig->params [0]->type != MONO_TYPE_STRING) continue; if (count == 2 && sig->params [1]->type != MONO_TYPE_STRING) continue; method = m; break; } args [0] = a1; args [1] = a2; mono_runtime_invoke_checked (method, o, args, &error); mono_error_raise_exception (&error); /* FIXME don't raise here */ return (MonoException *) o; }
/* * Context propagation is required when: * (a) the security manager is active (1.x and later) * (b) other contexts needs to be propagated (2.x and later) * * returns NULL if no context propagation is required, else the returns the * MonoMethod to call to Capture the ExecutionContext. */ MonoMethod* mono_get_context_capture_method (void) { static MonoMethod *method = NULL; if (mono_image_get_assembly (mono_defaults.corlib)->aname.major < 2) return NULL; /* older corlib revisions won't have the class (nor the method) */ MonoClass *execution_context = mono_class_try_get_execution_context_class (); if (execution_context && !method) { ERROR_DECL (error); mono_class_init_internal (execution_context); method = mono_class_get_method_from_name_checked (execution_context, "Capture", 0, 0, error); mono_error_assert_ok (error); } return method; }
static void throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, gboolean rethrow, gboolean preserve_ips) { ERROR_DECL (error); MonoContext ctx; #ifdef DEBUG_EXCEPTIONS g_print ("throw_exception: exc=%p eip=%p esp=%p rethrow=%d\n", exc, (void *)eip, (void *) esp, rethrow); #endif /* adjust eip so that it point into the call instruction */ eip -= 8; memset (&ctx, 0, sizeof (MonoContext)); /*g_print ("stack in throw: %p\n", esp);*/ memcpy (&ctx.sc_regs, (void *)(esp + MIPS_STACK_PARAM_OFFSET), sizeof (gulong) * MONO_SAVED_GREGS); memset (&ctx.sc_fpregs, 0, sizeof (mips_freg) * MONO_SAVED_FREGS); MONO_CONTEXT_SET_IP (&ctx, eip); if (mono_object_isinst_checked (exc, mono_defaults.exception_class, error)) { MonoException *mono_ex = (MonoException*)exc; if (!rethrow) { mono_ex->stack_trace = NULL; mono_ex->trace_ips = NULL; } if (preserve_ips) { mono_ex->caught_in_unmanaged = TRUE; } } mono_error_assert_ok (error); mono_handle_exception (&ctx, exc); #ifdef DEBUG_EXCEPTIONS g_print ("throw_exception: restore to pc=%p sp=%p fp=%p ctx=%p\n", (void *) ctx.sc_pc, (void *) ctx.sc_regs[mips_sp], (void *) ctx.sc_regs[mips_fp], &ctx); #endif mono_restore_context (&ctx); g_assert_not_reached (); }
void mono_runtime_setup_stat_profiler (void) { /* * Use a real-time signal when possible. This gives us roughly a 99% signal * delivery rate in all cases. On the other hand, using a regular signal * tends to result in awful delivery rates when the application is heavily * loaded. * * We avoid real-time signals on Android as they're super broken in certain * API levels (too small sigset_t, nonsensical SIGRTMIN/SIGRTMAX values, * etc). * * TODO: On Mac, we should explore using the Mach thread suspend/resume * functions and doing the stack walk from the sampling thread. This would * get us a 100% sampling rate. However, this may interfere with the GC's * STW logic. Could perhaps be solved by taking the suspend lock. */ #if defined (USE_POSIX_BACKEND) && defined (SIGRTMIN) && !defined (HOST_ANDROID) /* Just take the first real-time signal we can get. */ profiler_signal = mono_threads_suspend_search_alternative_signal (); #else profiler_signal = SIGPROF; #endif add_signal_handler (profiler_signal, profiler_signal_handler, SA_RESTART); mono_counters_register ("Sampling signals sent", MONO_COUNTER_UINT | MONO_COUNTER_PROFILER | MONO_COUNTER_MONOTONIC, &profiler_signals_sent); mono_counters_register ("Sampling signals received", MONO_COUNTER_UINT | MONO_COUNTER_PROFILER | MONO_COUNTER_MONOTONIC, &profiler_signals_received); mono_counters_register ("Sampling signals accepted", MONO_COUNTER_UINT | MONO_COUNTER_PROFILER | MONO_COUNTER_MONOTONIC, &profiler_signals_accepted); mono_counters_register ("Shutdown signals received", MONO_COUNTER_UINT | MONO_COUNTER_PROFILER | MONO_COUNTER_MONOTONIC, &profiler_interrupt_signals_received); mono_os_event_init (&sampling_thread_exited, FALSE); mono_atomic_store_i32 (&sampling_thread_running, 1); MonoError error; MonoInternalThread *thread = mono_thread_create_internal (mono_get_root_domain (), sampling_thread_func, NULL, MONO_THREAD_CREATE_FLAGS_NONE, &error); mono_error_assert_ok (&error); sampling_thread = MONO_UINT_TO_NATIVE_THREAD_ID (thread->tid); }
MonoExceptionHandle mono_get_exception_reflection_type_load_checked (MonoArrayHandle types, MonoArrayHandle exceptions, MonoError *error) { HANDLE_FUNCTION_ENTER (); MonoClass *klass; MonoMethod *method; gpointer iter; error_init (error); klass = mono_class_load_from_name (mono_get_corlib (), "System.Reflection", "ReflectionTypeLoadException"); mono_class_init_internal (klass); /* Find the Type[], Exception[] ctor */ iter = NULL; while ((method = mono_class_get_methods (klass, &iter))) { if (!strcmp (".ctor", mono_method_get_name (method))) { MonoMethodSignature *sig = mono_method_signature_internal (method); if (sig->param_count == 2 && sig->params [0]->type == MONO_TYPE_SZARRAY && sig->params [1]->type == MONO_TYPE_SZARRAY) break; } method = NULL; } g_assert (method); MonoExceptionHandle exc = MONO_HANDLE_CAST (MonoException, MONO_HANDLE_NEW (MonoObject, mono_object_new_checked (mono_domain_get (), klass, error))); mono_error_assert_ok (error); gpointer args [ ] = { MONO_HANDLE_RAW (types), MONO_HANDLE_RAW (exceptions) }; mono_runtime_invoke_checked (method, MONO_HANDLE_RAW (exc), args, error); goto_if_nok (error, return_null); goto exit; return_null: exc = MONO_HANDLE_CAST (MonoException, mono_new_null ()); exit: HANDLE_FUNCTION_RETURN_REF (MonoException, exc); }
static gboolean saved_strings_find_func (gpointer key, gpointer value, gpointer user_data) { MonoError error; SavedStringFindInfo *info = (SavedStringFindInfo*)user_data; SavedString *saved = (SavedString*)value; gchar *utf_str; guint32 hash; if (!info || !saved || mono_string_length (saved->string) != info->len) return FALSE; utf_str = mono_string_to_utf8_checked (saved->string, &error); mono_error_assert_ok (&error); hash = do_calc_string_hash (0, utf_str); g_free (utf_str); if (hash != info->hash) return FALSE; return TRUE; }
/* * mono_x86_throw_exception: * * C function called from the throw trampolines. */ void mono_x86_throw_exception (mgreg_t *regs, MonoObject *exc, mgreg_t eip, gboolean rethrow) { MonoError error; MonoContext ctx; ctx.esp = regs [X86_ESP]; ctx.eip = eip; ctx.ebp = regs [X86_EBP]; ctx.edi = regs [X86_EDI]; ctx.esi = regs [X86_ESI]; ctx.ebx = regs [X86_EBX]; ctx.edx = regs [X86_EDX]; ctx.ecx = regs [X86_ECX]; ctx.eax = regs [X86_EAX]; #ifdef __APPLE__ /* The OSX ABI specifies 16 byte alignment at call sites */ g_assert ((ctx.esp % MONO_ARCH_FRAME_ALIGNMENT) == 0); #endif if (mono_object_isinst_checked (exc, mono_defaults.exception_class, &error)) { MonoException *mono_ex = (MonoException*)exc; if (!rethrow) { mono_ex->stack_trace = NULL; mono_ex->trace_ips = NULL; } } mono_error_assert_ok (&error); /* adjust eip so that it point into the call instruction */ ctx.eip -= 1; mono_handle_exception (&ctx, exc); mono_restore_context (&ctx); g_assert_not_reached (); }
/* * mono_arm_throw_exception: * * This function is called by the exception trampolines. * FP_REGS points to the 8 callee saved fp regs. */ void mono_arm_throw_exception (gpointer arg, mgreg_t pc, mgreg_t *int_regs, gdouble *fp_regs, gboolean corlib, gboolean rethrow) { MonoError error; MonoContext ctx; MonoObject *exc = NULL; guint32 ex_token_index, ex_token; if (!corlib) exc = arg; else { ex_token_index = (guint64)arg; ex_token = MONO_TOKEN_TYPE_DEF | ex_token_index; exc = (MonoObject*)mono_exception_from_token (mono_defaults.corlib, ex_token); } /* Adjust pc so it points into the call instruction */ pc -= 4; /* Initialize a ctx based on the arguments */ memset (&ctx, 0, sizeof (MonoContext)); memcpy (&(ctx.regs [0]), int_regs, sizeof (mgreg_t) * 32); memcpy (&(ctx.fregs [ARMREG_D8]), fp_regs, sizeof (double) * 8); ctx.has_fregs = 1; ctx.pc = pc; if (mono_object_isinst_checked (exc, mono_defaults.exception_class, &error)) { MonoException *mono_ex = (MonoException*)exc; if (!rethrow) { mono_ex->stack_trace = NULL; mono_ex->trace_ips = NULL; } } mono_error_assert_ok (&error); mono_handle_exception (&ctx, exc); mono_restore_context (&ctx); }
static MonoExceptionHandle create_exception_two_strings (MonoClass *klass, MonoStringHandle a1, MonoStringHandle a2, MonoError *error) { HANDLE_FUNCTION_ENTER (); MonoMethod *method = NULL; int const count = 1 + !MONO_HANDLE_IS_NULL (a2); gpointer iter; MonoMethod *m; MonoObjectHandle o = mono_object_new_handle (mono_domain_get (), klass, error); mono_error_assert_ok (error); iter = NULL; while ((m = mono_class_get_methods (klass, &iter))) { MonoMethodSignature *sig; if (strcmp (".ctor", mono_method_get_name (m))) continue; sig = mono_method_signature_internal (m); if (sig->param_count != count) continue; if (sig->params [0]->type != MONO_TYPE_STRING) continue; if (count == 2 && sig->params [1]->type != MONO_TYPE_STRING) continue; method = m; break; } gpointer args [ ] = { MONO_HANDLE_RAW (a1), MONO_HANDLE_RAW (a2) }; mono_runtime_invoke_handle (method, o, args, error); if (!is_ok (error)) o = mono_new_null (); HANDLE_FUNCTION_RETURN_REF (MonoException, MONO_HANDLE_CAST (MonoException, o)); }
/** * mono_get_exception_reflection_type_load: * @types: an array of types that were defined in the moduled loaded. * @exceptions: an array of exceptions that were thrown during the type loading. * * Returns: a new instance of the `System.Reflection.ReflectionTypeLoadException` */ MonoException * mono_get_exception_reflection_type_load (MonoArray *types, MonoArray *exceptions) { MonoError error; MonoClass *klass; gpointer args [2]; MonoObject *exc; MonoMethod *method; gpointer iter; klass = mono_class_load_from_name (mono_get_corlib (), "System.Reflection", "ReflectionTypeLoadException"); mono_class_init (klass); /* Find the Type[], Exception[] ctor */ iter = NULL; while ((method = mono_class_get_methods (klass, &iter))) { if (!strcmp (".ctor", mono_method_get_name (method))) { MonoMethodSignature *sig = mono_method_signature (method); if (sig->param_count == 2 && sig->params [0]->type == MONO_TYPE_SZARRAY && sig->params [1]->type == MONO_TYPE_SZARRAY) break; } method = NULL; } g_assert (method); args [0] = types; args [1] = exceptions; exc = mono_object_new_checked (mono_domain_get (), klass, &error); mono_error_assert_ok (&error); mono_runtime_invoke_checked (method, exc, args, &error); mono_error_raise_exception (&error); /* FIXME don't raise here */ return (MonoException *) exc; }
/** * mono_get_exception_type_initialization: * @type_name: the name of the type that failed to initialize. * @inner: the inner exception. * * Returns: a new instance of the `System.TypeInitializationException` */ MonoException * mono_get_exception_type_initialization (const gchar *type_name, MonoException *inner) { MonoError error; MonoClass *klass; gpointer args [2]; MonoObject *exc; MonoMethod *method; gpointer iter; klass = mono_class_load_from_name (mono_get_corlib (), "System", "TypeInitializationException"); mono_class_init (klass); iter = NULL; while ((method = mono_class_get_methods (klass, &iter))) { if (!strcmp (".ctor", mono_method_get_name (method))) { MonoMethodSignature *sig = mono_method_signature (method); if (sig->param_count == 2 && sig->params [0]->type == MONO_TYPE_STRING && mono_class_from_mono_type (sig->params [1]) == mono_defaults.exception_class) break; } method = NULL; } g_assert (method); args [0] = mono_string_new (mono_domain_get (), type_name); args [1] = inner; exc = mono_object_new_checked (mono_domain_get (), klass, &error); mono_error_assert_ok (&error); mono_runtime_invoke_checked (method, exc, args, &error); mono_error_raise_exception (&error); /* FIXME don't raise here */ return (MonoException *) exc; }