2009-02-03 Zoltan Varga <vargaz@gmail.com>

[mono.git] / mono / mini / jit-icalls.c

diff --git a/mono/mini/jit-icalls.c b/mono/mini/jit-icalls.c
index 0b105b57ced3f3042d1fa5774e811a434628f5ee..49aaa866546e29966d06cc80286967a322341545 100644 (file)
--- a/mono/mini/jit-icalls.c
+++ b/mono/mini/jit-icalls.c
@@ -7,9 +7,12 @@
  *
  * (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"
 
@@ -20,22 +23,6 @@ mono_ldftn (MonoMethod *method)
 
        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);
@@ -65,11 +52,8 @@ ldvirtfn_internal (MonoObject *obj, MonoMethod *method, gboolean gshared)
                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);
 }
@@ -304,7 +288,7 @@ mono_irem_un (guint32 a, guint32 b)
 
 #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)
@@ -323,7 +307,7 @@ mono_imul_ovf (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;
@@ -616,6 +600,17 @@ mono_fclt_un (double a, double b)
        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)
 {
@@ -680,6 +675,34 @@ mono_array_new_va (MonoMethod *cm, ...)
 }
 
 /* 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)
 {
@@ -875,10 +898,11 @@ mono_lconv_to_r8_un (guint64 a)
 #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++;
 
@@ -896,12 +920,8 @@ mono_helper_compile_generic_method (MonoObject *obj, MonoMethod *method, MonoGen
        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 */
@@ -913,14 +933,6 @@ mono_helper_compile_generic_method (MonoObject *obj, MonoMethod *method, MonoGen
        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)
 {