*
* (C) 2002 Ximian, Inc.
*/
-
+#include <config.h>
#include <math.h>
+#include <limits.h>
+#ifdef HAVE_ALLOCA_H
+#include <alloca.h>
+#endif
#include "jit-icalls.h"
MONO_ARCH_SAVE_REGS;
- addr = mono_create_jump_trampoline (mono_domain_get (), method, TRUE);
-
- return mono_create_ftnptr (mono_domain_get (), addr);
-}
-
-/*
- * Same as mono_ldftn, but do not add a synchronized wrapper. Used in the
- * synchronized wrappers to avoid infinite recursion.
- */
-void*
-mono_ldftn_nosync (MonoMethod *method)
-{
- gpointer addr;
-
- MONO_ARCH_SAVE_REGS;
-
addr = mono_create_jump_trampoline (mono_domain_get (), method, FALSE);
return mono_create_ftnptr (mono_domain_get (), addr);
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)) {
+ if (mono_method_needs_static_rgctx_invoke (res, FALSE))
res = mono_marshal_get_static_rgctx_invoke (res);
- }
return mono_ldftn (res);
}
#endif
-#ifdef MONO_ARCH_EMULATE_MUL_DIV
+#if defined(MONO_ARCH_EMULATE_MUL_DIV) || defined(MONO_ARCH_EMULATE_MUL_OVF)
gint32
mono_imul (gint32 a, gint32 b)
res = (gint64)a * (gint64)b;
- if ((res > 0x7fffffffL) || (res < -2147483648))
+ if ((res > 0x7fffffffL) || (res < -2147483648LL))
mono_raise_exception (mono_get_exception_overflow ());
return res;
return isunordered (a, b) || a < b;
}
+gboolean
+mono_isfinite (double a)
+{
+#ifdef HAVE_ISFINITE
+ return isfinite (a);
+#else
+ g_assert_not_reached ();
+ return TRUE;
+#endif
+}
+
double
mono_fload_r4 (float *ptr)
{
}
/* Specialized version of mono_array_new_va () which avoids varargs */
+MonoArray *
+mono_array_new_1 (MonoMethod *cm, guint32 length)
+{
+ MonoDomain *domain = mono_domain_get ();
+ guint32 lengths [1];
+ guint32 *lower_bounds;
+ int pcount;
+ int rank;
+
+ MONO_ARCH_SAVE_REGS;
+
+ pcount = mono_method_signature (cm)->param_count;
+ rank = cm->klass->rank;
+
+ lengths [0] = length;
+
+ 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);
+}
+
MonoArray *
mono_array_new_2 (MonoMethod *cm, guint32 length1, guint32 length2)
{
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;
}
#endif
gpointer
-mono_helper_compile_generic_method (MonoObject *obj, MonoMethod *method, MonoGenericContext *context, gpointer *this_arg)
+mono_helper_compile_generic_method (MonoObject *obj, MonoMethod *method, gpointer *this_arg)
{
MonoMethod *vmethod, *inflated;
gpointer addr;
+ MonoGenericContext *context = mono_method_get_context (method);
mono_jit_stats.generic_virtual_invocations++;
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. */
+ if (mono_method_needs_static_rgctx_invoke (inflated, FALSE))
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)
{