[jit] Add support for char/boolean to mini_type_get_underlying_type ().

diff --git a/mono/mini/method-to-ir.c b/mono/mini/method-to-ir.c
index dee6f35c7ae21c0816aa00adcba9dd2060573b5e..fe32fbd3c0d113e03ff71ecbb077906d2a46bd65 100755 (executable)
--- a/mono/mini/method-to-ir.c
+++ b/mono/mini/method-to-ir.c
@@ -281,11 +281,9 @@ handle_enum:
        switch (type->type) {
        case MONO_TYPE_I1:
        case MONO_TYPE_U1:
-       case MONO_TYPE_BOOLEAN:
                return OP_MOVE;
        case MONO_TYPE_I2:
        case MONO_TYPE_U2:
-       case MONO_TYPE_CHAR:
                return OP_MOVE;
        case MONO_TYPE_I4:
        case MONO_TYPE_U4:
@@ -752,10 +750,8 @@ handle_enum:
                return;
        case MONO_TYPE_I1:
        case MONO_TYPE_U1:
-       case MONO_TYPE_BOOLEAN:
        case MONO_TYPE_I2:
        case MONO_TYPE_U2:
-       case MONO_TYPE_CHAR:
        case MONO_TYPE_I4:
        case MONO_TYPE_U4:
                inst->type = STACK_I4;
@@ -1290,10 +1286,8 @@ type_to_stack_type (MonoCompile *cfg, MonoType *t)
        switch (t->type) {
        case MONO_TYPE_I1:
        case MONO_TYPE_U1:
-       case MONO_TYPE_BOOLEAN:
        case MONO_TYPE_I2:
        case MONO_TYPE_U2:
-       case MONO_TYPE_CHAR:
        case MONO_TYPE_I4:
        case MONO_TYPE_U4:
                return STACK_I4;
@@ -2147,10 +2141,8 @@ handle_enum:
                return calli? OP_VOIDCALL_REG: virt? OP_VOIDCALL_MEMBASE: OP_VOIDCALL;
        case MONO_TYPE_I1:
        case MONO_TYPE_U1:
-       case MONO_TYPE_BOOLEAN:
        case MONO_TYPE_I2:
        case MONO_TYPE_U2:
-       case MONO_TYPE_CHAR:
        case MONO_TYPE_I4:
        case MONO_TYPE_U4:
                return calli? OP_CALL_REG: virt? OP_CALL_MEMBASE: OP_CALL;
@@ -2228,10 +2220,8 @@ target_type_is_incompatible (MonoCompile *cfg, MonoType *target, MonoInst *arg)
                return 1;
        case MONO_TYPE_I1:
        case MONO_TYPE_U1:
-       case MONO_TYPE_BOOLEAN:
        case MONO_TYPE_I2:
        case MONO_TYPE_U2:
-       case MONO_TYPE_CHAR:
        case MONO_TYPE_I4:
        case MONO_TYPE_U4:
                if (arg->type != STACK_I4 && arg->type != STACK_PTR)
@@ -2353,10 +2343,8 @@ handle_enum:
                        continue;
                case MONO_TYPE_I1:
                case MONO_TYPE_U1:
-               case MONO_TYPE_BOOLEAN:
                case MONO_TYPE_I2:
                case MONO_TYPE_U2:
-               case MONO_TYPE_CHAR:
                case MONO_TYPE_I4:
                case MONO_TYPE_U4:
                        if (args [i]->type != STACK_I4 && args [i]->type != STACK_PTR)

diff --git a/mono/mini/mini-amd64.c b/mono/mini/mini-amd64.c
index c0c234b6edf5d81a1414f3c974220a146a0f12ba..f8f0cf06613ef0fa05a9a04846d0d4e451e1125a 100755 (executable)
--- a/mono/mini/mini-amd64.c
+++ b/mono/mini/mini-amd64.c
@@ -594,8 +594,6 @@ merge_argument_class_from_type (MonoGenericSharingContext *gsctx, MonoType *type
 
        ptype = mini_type_get_underlying_type (gsctx, type);
        switch (ptype->type) {
-       case MONO_TYPE_BOOLEAN:
-       case MONO_TYPE_CHAR:
        case MONO_TYPE_I1:
        case MONO_TYPE_U1:
        case MONO_TYPE_I2:
@@ -1011,73 +1009,69 @@ get_call_info (MonoGenericSharingContext *gsctx, MonoMemPool *mp, MonoMethodSign
 #endif
 
        /* return value */
-       {
-               ret_type = mini_type_get_underlying_type (gsctx, sig->ret);
-               switch (ret_type->type) {
-               case MONO_TYPE_BOOLEAN:
-               case MONO_TYPE_I1:
-               case MONO_TYPE_U1:
-               case MONO_TYPE_I2:
-               case MONO_TYPE_U2:
-               case MONO_TYPE_CHAR:
-               case MONO_TYPE_I4:
-               case MONO_TYPE_U4:
-               case MONO_TYPE_I:
-               case MONO_TYPE_U:
-               case MONO_TYPE_PTR:
-               case MONO_TYPE_FNPTR:
-               case MONO_TYPE_CLASS:
-               case MONO_TYPE_OBJECT:
-               case MONO_TYPE_SZARRAY:
-               case MONO_TYPE_ARRAY:
-               case MONO_TYPE_STRING:
-                       cinfo->ret.storage = ArgInIReg;
-                       cinfo->ret.reg = AMD64_RAX;
-                       break;
-               case MONO_TYPE_U8:
-               case MONO_TYPE_I8:
+       ret_type = mini_type_get_underlying_type (gsctx, sig->ret);
+       switch (ret_type->type) {
+       case MONO_TYPE_I1:
+       case MONO_TYPE_U1:
+       case MONO_TYPE_I2:
+       case MONO_TYPE_U2:
+       case MONO_TYPE_I4:
+       case MONO_TYPE_U4:
+       case MONO_TYPE_I:
+       case MONO_TYPE_U:
+       case MONO_TYPE_PTR:
+       case MONO_TYPE_FNPTR:
+       case MONO_TYPE_CLASS:
+       case MONO_TYPE_OBJECT:
+       case MONO_TYPE_SZARRAY:
+       case MONO_TYPE_ARRAY:
+       case MONO_TYPE_STRING:
+               cinfo->ret.storage = ArgInIReg;
+               cinfo->ret.reg = AMD64_RAX;
+               break;
+       case MONO_TYPE_U8:
+       case MONO_TYPE_I8:
+               cinfo->ret.storage = ArgInIReg;
+               cinfo->ret.reg = AMD64_RAX;
+               break;
+       case MONO_TYPE_R4:
+               cinfo->ret.storage = ArgInFloatSSEReg;
+               cinfo->ret.reg = AMD64_XMM0;
+               break;
+       case MONO_TYPE_R8:
+               cinfo->ret.storage = ArgInDoubleSSEReg;
+               cinfo->ret.reg = AMD64_XMM0;
+               break;
+       case MONO_TYPE_GENERICINST:
+               if (!mono_type_generic_inst_is_valuetype (ret_type)) {
                        cinfo->ret.storage = ArgInIReg;
                        cinfo->ret.reg = AMD64_RAX;
                        break;
-               case MONO_TYPE_R4:
-                       cinfo->ret.storage = ArgInFloatSSEReg;
-                       cinfo->ret.reg = AMD64_XMM0;
-                       break;
-               case MONO_TYPE_R8:
-                       cinfo->ret.storage = ArgInDoubleSSEReg;
-                       cinfo->ret.reg = AMD64_XMM0;
-                       break;
-               case MONO_TYPE_GENERICINST:
-                       if (!mono_type_generic_inst_is_valuetype (ret_type)) {
-                               cinfo->ret.storage = ArgInIReg;
-                               cinfo->ret.reg = AMD64_RAX;
-                               break;
-                       }
-                       /* fall through */
+               }
+               /* fall through */
 #if defined( __native_client_codegen__ )
-               case MONO_TYPE_TYPEDBYREF:
+       case MONO_TYPE_TYPEDBYREF:
 #endif
-               case MONO_TYPE_VALUETYPE: {
-                       guint32 tmp_gr = 0, tmp_fr = 0, tmp_stacksize = 0;
+       case MONO_TYPE_VALUETYPE: {
+               guint32 tmp_gr = 0, tmp_fr = 0, tmp_stacksize = 0;
 
-                       add_valuetype (gsctx, sig, &cinfo->ret, ret_type, TRUE, &tmp_gr, &tmp_fr, &tmp_stacksize);
-                       if (cinfo->ret.storage == ArgOnStack) {
-                               cinfo->vtype_retaddr = TRUE;
-                               /* The caller passes the address where the value is stored */
-                       }
-                       break;
+               add_valuetype (gsctx, sig, &cinfo->ret, ret_type, TRUE, &tmp_gr, &tmp_fr, &tmp_stacksize);
+               if (cinfo->ret.storage == ArgOnStack) {
+                       cinfo->vtype_retaddr = TRUE;
+                       /* The caller passes the address where the value is stored */
                }
+               break;
+       }
 #if !defined( __native_client_codegen__ )
-               case MONO_TYPE_TYPEDBYREF:
-                       /* Same as a valuetype with size 24 */
-                       cinfo->vtype_retaddr = TRUE;
-                       break;
+       case MONO_TYPE_TYPEDBYREF:
+               /* Same as a valuetype with size 24 */
+               cinfo->vtype_retaddr = TRUE;
+               break;
 #endif
-               case MONO_TYPE_VOID:
-                       break;
-               default:
-                       g_error ("Can't handle as return value 0x%x", ret_type->type);
-               }
+       case MONO_TYPE_VOID:
+               break;
+       default:
+               g_error ("Can't handle as return value 0x%x", ret_type->type);
        }
 
        pstart = 0;
@@ -1141,14 +1135,12 @@ get_call_info (MonoGenericSharingContext *gsctx, MonoMemPool *mp, MonoMethodSign
 
                ptype = mini_type_get_underlying_type (gsctx, sig->params [i]);
                switch (ptype->type) {
-               case MONO_TYPE_BOOLEAN:
                case MONO_TYPE_I1:
                case MONO_TYPE_U1:
                        add_general (&gr, &stack_size, ainfo);
                        break;
                case MONO_TYPE_I2:
                case MONO_TYPE_U2:
-               case MONO_TYPE_CHAR:
                        add_general (&gr, &stack_size, ainfo);
                        break;
                case MONO_TYPE_I4:
@@ -2687,7 +2679,7 @@ mono_arch_start_dyn_call (MonoDynCallInfo *info, gpointer **args, guint8 *ret, g
                p->regs [greg ++] = PTR_TO_GREG(ret);
 
        for (i = pindex; i < sig->param_count; i++) {
-               MonoType *t = mono_type_get_underlying_type (sig->params [i]);
+               MonoType *t = mini_type_get_underlying_type (NULL, sig->params [i]);
                gpointer *arg = args [arg_index ++];
 
                if (t->byref) {
@@ -2718,7 +2710,6 @@ mono_arch_start_dyn_call (MonoDynCallInfo *info, gpointer **args, guint8 *ret, g
                        p->regs [greg ++] = *(guint64*)(arg);
                        break;
 #endif
-               case MONO_TYPE_BOOLEAN:
                case MONO_TYPE_U1:
                        p->regs [greg ++] = *(guint8*)(arg);
                        break;
@@ -2729,7 +2720,6 @@ mono_arch_start_dyn_call (MonoDynCallInfo *info, gpointer **args, guint8 *ret, g
                        p->regs [greg ++] = *(gint16*)(arg);
                        break;
                case MONO_TYPE_U2:
-               case MONO_TYPE_CHAR:
                        p->regs [greg ++] = *(guint16*)(arg);
                        break;
                case MONO_TYPE_I4:
@@ -2783,7 +2773,7 @@ mono_arch_finish_dyn_call (MonoDynCallInfo *info, guint8 *buf)
        MonoMethodSignature *sig = dinfo->sig;
        guint8 *ret = ((DynCallArgs*)buf)->ret;
        mgreg_t res = ((DynCallArgs*)buf)->res;
-       MonoType *sig_ret = mono_type_get_underlying_type (sig->ret);
+       MonoType *sig_ret = mini_type_get_underlying_type (NULL, sig->ret);
 
        switch (sig_ret->type) {
        case MONO_TYPE_VOID:
@@ -2803,14 +2793,12 @@ mono_arch_finish_dyn_call (MonoDynCallInfo *info, guint8 *buf)
                *(gint8*)ret = res;
                break;
        case MONO_TYPE_U1:
-       case MONO_TYPE_BOOLEAN:
                *(guint8*)ret = res;
                break;
        case MONO_TYPE_I2:
                *(gint16*)ret = res;
                break;
        case MONO_TYPE_U2:
-       case MONO_TYPE_CHAR:
                *(guint16*)ret = res;
                break;
        case MONO_TYPE_I4:

diff --git a/mono/mini/mini-arm.c b/mono/mini/mini-arm.c
index d89c46b500e02d5185b226eab391f81bc1d9c65c..2d0ef57b9931d620a7ea17611bcac7d23fb74744 100644 (file)
--- a/mono/mini/mini-arm.c
+++ b/mono/mini/mini-arm.c
@@ -1487,14 +1487,12 @@ get_call_info (MonoGenericSharingContext *gsctx, MonoMemPool *mp, MonoMethodSign
                }
                simpletype = mini_type_get_underlying_type (gsctx, sig->params [i]);
                switch (simpletype->type) {
-               case MONO_TYPE_BOOLEAN:
                case MONO_TYPE_I1:
                case MONO_TYPE_U1:
                        cinfo->args [n].size = 1;
                        add_general (&gr, &stack_size, ainfo, TRUE);
                        n++;
                        break;
-               case MONO_TYPE_CHAR:
                case MONO_TYPE_I2:
                case MONO_TYPE_U2:
                        cinfo->args [n].size = 2;
@@ -1658,12 +1656,10 @@ get_call_info (MonoGenericSharingContext *gsctx, MonoMemPool *mp, MonoMethodSign
        {
                simpletype = mini_type_get_underlying_type (gsctx, sig->ret);
                switch (simpletype->type) {
-               case MONO_TYPE_BOOLEAN:
                case MONO_TYPE_I1:
                case MONO_TYPE_U1:
                case MONO_TYPE_I2:
                case MONO_TYPE_U2:
-               case MONO_TYPE_CHAR:
                case MONO_TYPE_I4:
                case MONO_TYPE_U4:
                case MONO_TYPE_I:
@@ -2728,10 +2724,10 @@ mono_arch_dyn_call_prepare (MonoMethodSignature *sig)
        // FIXME: Preprocess the info to speed up start_dyn_call ()
        info->sig = sig;
        info->cinfo = cinfo;
-       info->rtype = mini_replace_type (sig->ret);
+       info->rtype = mini_type_get_underlying_type (NULL, sig->ret);
        info->param_types = g_new0 (MonoType*, sig->param_count);
        for (i = 0; i < sig->param_count; ++i)
-               info->param_types [i] = mini_replace_type (sig->params [i]);
+               info->param_types [i] = mini_type_get_underlying_type (NULL, sig->params [i]);
        
        return (MonoDynCallInfo*)info;
 }
@@ -2800,7 +2796,6 @@ mono_arch_start_dyn_call (MonoDynCallInfo *info, gpointer **args, guint8 *ret, g
                case MONO_TYPE_U:
                        p->regs [slot] = (mgreg_t)*arg;
                        break;
-               case MONO_TYPE_BOOLEAN:
                case MONO_TYPE_U1:
                        p->regs [slot] = *(guint8*)arg;
                        break;
@@ -2811,7 +2806,6 @@ mono_arch_start_dyn_call (MonoDynCallInfo *info, gpointer **args, guint8 *ret, g
                        p->regs [slot] = *(gint16*)arg;
                        break;
                case MONO_TYPE_U2:
-               case MONO_TYPE_CHAR:
                        p->regs [slot] = *(guint16*)arg;
                        break;
                case MONO_TYPE_I4:
@@ -2883,14 +2877,12 @@ mono_arch_finish_dyn_call (MonoDynCallInfo *info, guint8 *buf)
                *(gint8*)ret = res;
                break;
        case MONO_TYPE_U1:
-       case MONO_TYPE_BOOLEAN:
                *(guint8*)ret = res;
                break;
        case MONO_TYPE_I2:
                *(gint16*)ret = res;
                break;
        case MONO_TYPE_U2:
-       case MONO_TYPE_CHAR:
                *(guint16*)ret = res;
                break;
        case MONO_TYPE_I4:

diff --git a/mono/mini/mini-codegen.c b/mono/mini/mini-codegen.c
index 39b0314ea9a8c75130d3d7219a4d60487d19222a..a9c134cc4fe06b02f75e27763b679837622ad35d 100644 (file)
--- a/mono/mini/mini-codegen.c
+++ b/mono/mini/mini-codegen.c
@@ -2492,12 +2492,8 @@ mono_opcode_to_type (int opcode, int cmp_opcode)
 gboolean
 mono_is_regsize_var (MonoType *t)
 {
-       if (t->byref)
-               return TRUE;
-       t = mono_type_get_underlying_type (t);
+       t = mini_type_get_underlying_type (NULL, t);
        switch (t->type) {
-       case MONO_TYPE_BOOLEAN:
-       case MONO_TYPE_CHAR:
        case MONO_TYPE_I1:
        case MONO_TYPE_U1:
        case MONO_TYPE_I2:

diff --git a/mono/mini/mini-generic-sharing.c b/mono/mini/mini-generic-sharing.c
index 7e51faa6392d5e42fb41be80a5b8e12f07e9d991..4a221b24fcca4f389fc52b40d3c456f3f4094451 100644 (file)
--- a/mono/mini/mini-generic-sharing.c
+++ b/mono/mini/mini-generic-sharing.c
@@ -2571,7 +2571,7 @@ mini_get_basic_type_from_generic (MonoGenericSharingContext *gsctx, MonoType *ty
 /*
  * mini_type_get_underlying_type:
  *
- *   Return the underlying type of TYPE, taking into account enums, byref and generic
+ *   Return the underlying type of TYPE, taking into account enums, byref, bool, char and generic
  * sharing.
  */
 MonoType*
@@ -2583,7 +2583,15 @@ mini_type_get_underlying_type (MonoGenericSharingContext *gsctx, MonoType *type)
                return &mono_defaults.int_class->byval_arg;
        if (!type->byref && (type->type == MONO_TYPE_VAR || type->type == MONO_TYPE_MVAR) && mini_is_gsharedvt_type_gsctx (gsctx, type))
                return type;
-       return mini_get_basic_type_from_generic (gsctx, mono_type_get_underlying_type (type));
+       type = mini_get_basic_type_from_generic (gsctx, mono_type_get_underlying_type (type));
+       switch (type->type) {
+       case MONO_TYPE_BOOLEAN:
+               return &mono_defaults.byte_class->byval_arg;
+       case MONO_TYPE_CHAR:
+               return &mono_defaults.uint16_class->byval_arg;
+       default:
+               return type;
+       }
 }
 
 /*

diff --git a/mono/mini/mini-x86.c b/mono/mini/mini-x86.c
index 7f213efd28da480380e4a6098b60a75866c25a08..9d42da2b5d30874c8240c5c6142d088fd1253002 100644 (file)
--- a/mono/mini/mini-x86.c
+++ b/mono/mini/mini-x86.c
@@ -392,12 +392,10 @@ get_call_info_internal (MonoGenericSharingContext *gsctx, CallInfo *cinfo, MonoM
        {
                ret_type = mini_type_get_underlying_type (gsctx, sig->ret);
                switch (ret_type->type) {
-               case MONO_TYPE_BOOLEAN:
                case MONO_TYPE_I1:
                case MONO_TYPE_U1:
                case MONO_TYPE_I2:
                case MONO_TYPE_U2:
-               case MONO_TYPE_CHAR:
                case MONO_TYPE_I4:
                case MONO_TYPE_U4:
                case MONO_TYPE_I:
@@ -517,14 +515,12 @@ get_call_info_internal (MonoGenericSharingContext *gsctx, CallInfo *cinfo, MonoM
                }
                ptype = mini_type_get_underlying_type (gsctx, sig->params [i]);
                switch (ptype->type) {
-               case MONO_TYPE_BOOLEAN:
                case MONO_TYPE_I1:
                case MONO_TYPE_U1:
                        add_general (&gr, param_regs, &stack_size, ainfo);
                        break;
                case MONO_TYPE_I2:
                case MONO_TYPE_U2:
-               case MONO_TYPE_CHAR:
                        add_general (&gr, param_regs, &stack_size, ainfo);
                        break;
                case MONO_TYPE_I4:

diff --git a/mono/mini/mini.c b/mono/mini/mini.c
index 49c74cbf7689f17cf76fb952c4747765d96e8cbb..ef9dbf0e06cf59935cf3678bd684ffdb65905192 100755 (executable)
--- a/mono/mini/mini.c
+++ b/mono/mini/mini.c
@@ -429,11 +429,9 @@ handle_enum:
        switch (type->type) {
        case MONO_TYPE_I1:
        case MONO_TYPE_U1:
-       case MONO_TYPE_BOOLEAN:
                return OP_STOREI1_MEMBASE_REG;
        case MONO_TYPE_I2:
        case MONO_TYPE_U2:
-       case MONO_TYPE_CHAR:
                return OP_STOREI2_MEMBASE_REG;
        case MONO_TYPE_I4:
        case MONO_TYPE_U4:
@@ -488,12 +486,10 @@ mono_type_to_load_membase (MonoCompile *cfg, MonoType *type)
        case MONO_TYPE_I1:
                return OP_LOADI1_MEMBASE;
        case MONO_TYPE_U1:
-       case MONO_TYPE_BOOLEAN:
                return OP_LOADU1_MEMBASE;
        case MONO_TYPE_I2:
                return OP_LOADI2_MEMBASE;
        case MONO_TYPE_U2:
-       case MONO_TYPE_CHAR:
                return OP_LOADU2_MEMBASE;
        case MONO_TYPE_I4:
                return OP_LOADI4_MEMBASE;