*/
#include <math.h>
+#include <limits.h>
#include "jit-icalls.h"
return mono_create_ftnptr (mono_domain_get (), addr);
}
-void*
-mono_ldvirtfn (MonoObject *obj, MonoMethod *method)
+static void*
+ldvirtfn_internal (MonoObject *obj, MonoMethod *method, gboolean gshared)
{
+ MonoMethod *res;
+
MONO_ARCH_SAVE_REGS;
if (obj == NULL)
mono_raise_exception (mono_get_exception_null_reference ());
- method = mono_object_get_virtual_method (obj, method);
+ res = mono_object_get_virtual_method (obj, method);
+
+ if (gshared && method->is_inflated && mono_method_get_context (method)->method_inst) {
+ MonoGenericContext context = { NULL, NULL };
+
+ if (res->klass->generic_class)
+ context.class_inst = res->klass->generic_class->context.class_inst;
+ else if (res->klass->generic_container)
+ context.class_inst = res->klass->generic_container->context.class_inst;
+ context.method_inst = mono_method_get_context (method)->method_inst;
+
+ res = mono_class_inflate_generic_method (res, &context);
+ }
+
+ /* FIXME: only do this for methods which can be shared! */
+ if (res->is_inflated && mono_method_get_context (res)->method_inst &&
+ mono_class_generic_sharing_enabled (res->klass)) {
+ res = mono_marshal_get_static_rgctx_invoke (res);
+ }
+
+ return mono_ldftn (res);
+}
+
+void*
+mono_ldvirtfn (MonoObject *obj, MonoMethod *method)
+{
+ return ldvirtfn_internal (obj, method, FALSE);
+}
- return mono_ldftn (method);
+void*
+mono_ldvirtfn_gshared (MonoObject *obj, MonoMethod *method)
+{
+ return ldvirtfn_internal (obj, method, TRUE);
}
void
gboolean
mono_fcgt_un (double a, double b)
{
- return a > b;
+ return isunordered (a, b) || a > b;
}
gboolean
gboolean
mono_fclt_un (double a, double b)
{
- return a < b;
+ return isunordered (a, b) || a < b;
}
double
return mono_array_new_full (domain, cm->klass, lengths, lower_bounds);
}
+/* Specialized version of mono_array_new_va () which avoids varargs */
+MonoArray *
+mono_array_new_2 (MonoMethod *cm, guint32 length1, guint32 length2)
+{
+ MonoDomain *domain = mono_domain_get ();
+ guint32 lengths [2];
+ guint32 *lower_bounds;
+ int pcount;
+ int rank;
+
+ MONO_ARCH_SAVE_REGS;
+
+ pcount = mono_method_signature (cm)->param_count;
+ rank = cm->klass->rank;
+
+ lengths [0] = length1;
+ lengths [1] = length2;
+
+ g_assert (rank == pcount);
+
+ if (cm->klass->byval_arg.type == MONO_TYPE_ARRAY) {
+ lower_bounds = alloca (sizeof (guint32) * rank);
+ memset (lower_bounds, 0, sizeof (guint32) * rank);
+ } else {
+ lower_bounds = NULL;
+ }
+
+ return mono_array_new_full (domain, cm->klass, lengths, lower_bounds);
+}
+
gpointer
mono_class_static_field_address (MonoDomain *domain, MonoClassField *field)
{
return res;
}
+gpointer
+mono_ldtoken_wrapper_generic_shared (MonoImage *image, int token, MonoMethod *method)
+{
+ MonoMethodSignature *sig = mono_method_signature (method);
+ MonoGenericContext *generic_context;
+
+ if (sig->is_inflated) {
+ generic_context = mono_method_get_context (method);
+ } else {
+ MonoGenericContainer *generic_container = mono_method_get_generic_container (method);
+ g_assert (generic_container);
+ generic_context = &generic_container->context;
+ }
+
+ return mono_ldtoken_wrapper (image, token, generic_context);
+}
+
guint64
mono_fconv_u8 (double v)
{
guint64 res;
MONO_ARCH_SAVE_REGS;
-
+/*
+ * The soft-float implementation of some ARM devices have a buggy guin64 to double
+ * conversion that it looses precision even when the integer if fully representable
+ * as a double.
+ *
+ * This was found with 4294967295ull, converting to double and back looses one bit of precision.
+ *
+ * To work around this issue we test for value boundaries instead.
+ */
+#if defined(__arm__) && MONO_ARCH_SOFT_FLOAT
+ if (isnan (v) || !(v >= -0.5 && v <= ULLONG_MAX+0.5)) {
+ mono_raise_exception (mono_get_exception_overflow ());
+ }
+ res = (guint64)v;
+#else
res = (guint64)v;
-
if (isnan(v) || trunc (v) != res) {
mono_raise_exception (mono_get_exception_overflow ());
}
+#endif
return res;
}
g_assert (!vmethod->klass->generic_class || !vmethod->klass->generic_class->context.class_inst->is_open);
g_assert (!context->method_inst || !context->method_inst->is_open);
inflated = mono_class_inflate_generic_method (vmethod, context);
+ if (mono_class_generic_sharing_enabled (inflated->klass) &&
+ mono_method_is_generic_sharable_impl (method, FALSE)) {
+ /* The method is shared generic code, so it needs a
+ MRGCTX. */
+ inflated = mono_marshal_get_static_rgctx_invoke (inflated);
+ }
addr = mono_compile_method (inflated);
/* Since this is a virtual call, have to unbox vtypes */
return addr;
}
+gpointer
+mono_helper_compile_generic_method_wo_context (MonoObject *obj, MonoMethod *method, gpointer *this_arg)
+{
+ MonoGenericContext *context = mono_method_get_context (method);
+
+ return mono_helper_compile_generic_method (obj, method, context, this_arg);
+}
+
MonoString*
mono_helper_ldstr (MonoImage *image, guint32 idx)
{
return mono_object_new (mono_domain_get (), klass);
}
+
+/*
+ * On some architectures, gdb doesn't like encountering the cpu breakpoint instructions
+ * in generated code. So instead we emit a call to this function and place a gdb
+ * breakpoint here.
+ */
+void
+mono_break (void)
+{
+}
+
+MonoException *
+mono_create_corlib_exception_0 (guint32 token)
+{
+ return mono_exception_from_token (mono_defaults.corlib, token);
+}
+
+MonoException *
+mono_create_corlib_exception_1 (guint32 token, MonoString *arg)
+{
+ return mono_exception_from_token_two_strings (mono_defaults.corlib, token, arg, NULL);
+}
+
+MonoException *
+mono_create_corlib_exception_2 (guint32 token, MonoString *arg1, MonoString *arg2)
+{
+ return mono_exception_from_token_two_strings (mono_defaults.corlib, token, arg1, arg2);
+}
+
+MonoObject*
+mono_object_castclass (MonoObject *obj, MonoClass *klass)
+{
+ if (!obj)
+ return NULL;
+
+ if (mono_object_isinst (obj, klass))
+ return obj;
+
+ mono_raise_exception (mono_exception_from_name (mono_defaults.corlib,
+ "System", "InvalidCastException"));
+
+ return NULL;
+}