#define ldstr_unlock() mono_os_mutex_unlock (&ldstr_section)
static mono_mutex_t ldstr_section;
+
/**
* mono_runtime_object_init:
* @this_obj: the object to initialize
#ifndef DISABLE_REMOTING
static gpointer
-default_remoting_trampoline (MonoDomain *domain, MonoMethod *method, MonoRemotingTarget target, MonoError *error)
+create_remoting_trampoline (MonoDomain *domain, MonoMethod *method, MonoRemotingTarget target, MonoError *error)
{
- g_error ("remoting not installed");
- return NULL;
+ if (!callbacks.create_remoting_trampoline)
+ g_error ("remoting not installed");
+ return callbacks.create_remoting_trampoline (domain, method, target, error);
}
-static MonoRemotingTrampoline arch_create_remoting_trampoline = default_remoting_trampoline;
#endif
-static gpointer
-default_delegate_trampoline (MonoDomain *domain, MonoClass *klass)
-{
- g_assert_not_reached ();
- return NULL;
-}
-
-static MonoDelegateTrampoline arch_create_delegate_trampoline = default_delegate_trampoline;
static MonoImtTrampolineBuilder imt_trampoline_builder;
static gboolean always_build_imt_trampolines;
return &callbacks;
}
-#ifndef DISABLE_REMOTING
-void
-mono_install_remoting_trampoline (MonoRemotingTrampoline func)
-{
- arch_create_remoting_trampoline = func? func: default_remoting_trampoline;
-}
-#endif
-
-void
-mono_install_delegate_trampoline (MonoDelegateTrampoline func)
-{
- arch_create_delegate_trampoline = func? func: default_delegate_trampoline;
-}
-
void
mono_install_imt_trampoline_builder (MonoImtTrampolineBuilder func)
{
mono_error_init (error);
- if (!callbacks.compile_method) {
- g_error ("compile method called on uninitialized runtime");
- return NULL;
- }
+ g_assert (callbacks.compile_method);
res = callbacks.compile_method (method, error);
return res;
}
{
MONO_REQ_GC_NEUTRAL_MODE
- return arch_create_delegate_trampoline (mono_domain_get (), klass);
-}
-
-static MonoFreeMethodFunc default_mono_free_method = NULL;
-
-/**
- * mono_install_free_method:
- * @func: pointer to the MonoFreeMethodFunc used to release a method
- *
- * This is an internal VM routine, it is used for the engines to
- * register a handler to release the resources associated with a method.
- *
- * Methods are freed when no more references to the delegate that holds
- * them are left.
- */
-void
-mono_install_free_method (MonoFreeMethodFunc func)
-{
- default_mono_free_method = func;
+ g_assert (callbacks.create_delegate_trampoline);
+ return callbacks.create_delegate_trampoline (mono_domain_get (), klass);
}
/**
{
MONO_REQ_GC_NEUTRAL_MODE
- if (default_mono_free_method != NULL)
- default_mono_free_method (domain, method);
+ if (callbacks.free_method)
+ callbacks.free_method (domain, method);
mono_method_clear_object (domain, method);
MonoMethod *cm;
if ((cm = klass->vtable [i])) {
- pvt->vtable [i] = arch_create_remoting_trampoline (domain, cm, target_type, error);
+ pvt->vtable [i] = create_remoting_trampoline (domain, cm, target_type, error);
if (!is_ok (error))
goto failure;
} else
gpointer iter = NULL;
while ((m = mono_class_get_methods (k, &iter)))
if (!pvt->vtable [m->slot]) {
- pvt->vtable [m->slot] = arch_create_remoting_trampoline (domain, m, target_type, error);
+ pvt->vtable [m->slot] = create_remoting_trampoline (domain, m, target_type, error);
if (!is_ok (error))
goto failure;
}
iter = NULL;
j = 0;
while ((cm = mono_class_get_methods (interf, &iter))) {
- pvt->vtable [slot + j++] = arch_create_remoting_trampoline (domain, cm, target_type, error);
+ pvt->vtable [slot + j++] = create_remoting_trampoline (domain, cm, target_type, error);
if (!is_ok (error))
goto failure;
}
return obj;
}
+ /* casting an array one of the invariant interfaces that must act as such */
+ if (klass->is_array_special_interface) {
+ if (mono_class_is_assignable_from (klass, vt->klass))
+ return obj;
+ }
+
/*If the above check fails we are in the slow path of possibly raising an exception. So it's ok to it this way.*/
- if (mono_class_has_variant_generic_params (klass) && mono_class_is_assignable_from (klass, obj->vtable->klass))
+ else if (mono_class_has_variant_generic_params (klass) && mono_class_is_assignable_from (klass, obj->vtable->klass))
return obj;
} else {
MonoClass *oklass = vt->klass;
return as;
}
+char *
+mono_string_handle_to_utf8 (MonoStringHandle s, MonoError *error)
+{
+ return mono_string_to_utf8_checked (MONO_HANDLE_RAW (s), error);
+}
+
/**
* mono_string_to_utf8_ignore:
* @s: a MonoString
+static char *
+get_native_backtrace (MonoException *exc_raw)
+{
+ HANDLE_FUNCTION_ENTER ();
+ MONO_HANDLE_DCL(MonoException, exc);
+ char * trace = mono_exception_handle_get_native_backtrace (exc);
+ HANDLE_FUNCTION_RETURN_VAL (trace);
+}
+
/**
* mono_print_unhandled_exception:
* @exc: The exception
} else {
if (((MonoException*)exc)->native_trace_ips) {
- message = mono_exception_get_native_backtrace ((MonoException*)exc);
+ message = get_native_backtrace ((MonoException*)exc);
free_message = TRUE;
} else {
MonoObject *other_exc = NULL;
MONO_OBJECT_SETREF (delegate, target, target);
}
- delegate->invoke_impl = arch_create_delegate_trampoline (delegate->object.vtable->domain, delegate->object.vtable->klass);
+ delegate->invoke_impl = callbacks.create_delegate_trampoline (delegate->object.vtable->domain, delegate->object.vtable->klass);
if (callbacks.init_delegate)
callbacks.init_delegate (delegate);
return TRUE;
projects / mono.git / blobdiff