[threads] Enable blocking transition with MONO_ENABLE_BLOCKING_TRANSITION env variabl...

[mono.git] / mono / mini / interp / transform.c

diff --git a/mono/mini/interp/transform.c b/mono/mini/interp/transform.c
index 57b50650a7bd6525d669d4616715d2470b692e0a..35592cb05e2bafe26b4b476b9c0925cd962710d5 100644 (file)
--- a/mono/mini/interp/transform.c
+++ b/mono/mini/interp/transform.c
@@ -751,6 +751,14 @@ interp_transform_call (TransformData *td, MonoMethod *method, MonoMethod *target
                csignature = mono_method_signature (target_method);
        }
 
+       if (target_method && target_method->string_ctor) {
+               /* Create the real signature */
+               MonoMethodSignature *ctor_sig = mono_metadata_signature_dup_mempool (td->mempool, csignature);
+               ctor_sig->ret = &mono_defaults.string_class->byval_arg;
+
+               csignature = ctor_sig;
+       }
+
        /* Intrinsics */
        if (target_method) {
                if (target_method->klass == mono_defaults.string_class) {
@@ -1321,6 +1329,14 @@ emit_seq_point (TransformData *td, int il_offset, InterpBasicBlock *cbb, gboolea
        cbb->last_seq_point = seqp;
 }
 
+#define BARRIER_IF_VOLATILE(td) \
+       do { \
+               if (volatile_) { \
+                       ADD_CODE (&td, MINT_MONO_MEMORY_BARRIER); \
+                       volatile_ = FALSE; \
+               } \
+       } while (0)
+
 static void
 generate (MonoMethod *method, RuntimeMethod *rtm, unsigned char *is_bb_start, MonoGenericContext *generic_context)
 {
@@ -1332,6 +1348,7 @@ generate (MonoMethod *method, RuntimeMethod *rtm, unsigned char *is_bb_start, Mo
        MonoError error;
        int offset, mt, i, i32;
        gboolean readonly = FALSE;
+       gboolean volatile_ = FALSE;
        MonoClass *klass;
        MonoClassField *field;
        const unsigned char *end;
@@ -1461,11 +1478,9 @@ generate (MonoMethod *method, RuntimeMethod *rtm, unsigned char *is_bb_start, Mo
                        td.stack_state [c->data.filter_offset][0].klass = NULL; /*FIX*/
                }
 
-               if ((c->flags & MONO_EXCEPTION_CLAUSE_FINALLY) || (c->flags & MONO_EXCEPTION_CLAUSE_FAULT)) {
-                       for (int j = c->handler_offset; j < c->handler_offset + c->handler_len; ++j) {
-                               if (td.clause_indexes [j] == -1)
-                                       td.clause_indexes [j] = i;
-                       }
+               for (int j = c->handler_offset; j < c->handler_offset + c->handler_len; ++j) {
+                       if (td.clause_indexes [j] == -1)
+                               td.clause_indexes [j] = i;
                }
        }
 
@@ -1940,95 +1955,114 @@ generate (MonoMethod *method, RuntimeMethod *rtm, unsigned char *is_bb_start, Mo
                        CHECK_STACK (&td, 1);
                        SIMPLE_OP (td, MINT_LDIND_I1);
                        SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
+                       BARRIER_IF_VOLATILE (td);
                        break;
                case CEE_LDIND_U1:
                        CHECK_STACK (&td, 1);
                        SIMPLE_OP (td, MINT_LDIND_U1);
                        SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
+                       BARRIER_IF_VOLATILE (td);
                        break;
                case CEE_LDIND_I2:
                        CHECK_STACK (&td, 1);
                        SIMPLE_OP (td, MINT_LDIND_I2);
                        SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
+                       BARRIER_IF_VOLATILE (td);
                        break;
                case CEE_LDIND_U2:
                        CHECK_STACK (&td, 1);
                        SIMPLE_OP (td, MINT_LDIND_U2);
                        SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
+                       BARRIER_IF_VOLATILE (td);
                        break;
                case CEE_LDIND_I4:
                        CHECK_STACK (&td, 1);
                        SIMPLE_OP (td, MINT_LDIND_I4);
                        SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
+                       BARRIER_IF_VOLATILE (td);
                        break;
                case CEE_LDIND_U4:
                        CHECK_STACK (&td, 1);
                        SIMPLE_OP (td, MINT_LDIND_U4);
                        SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
+                       BARRIER_IF_VOLATILE (td);
                        break;
                case CEE_LDIND_I8:
                        CHECK_STACK (&td, 1);
                        SIMPLE_OP (td, MINT_LDIND_I8);
                        SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I8);
+                       BARRIER_IF_VOLATILE (td);
                        break;
                case CEE_LDIND_I:
                        CHECK_STACK (&td, 1);
                        SIMPLE_OP (td, MINT_LDIND_I);
                        ADD_CODE (&td, 0);
                        SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I);
+                       BARRIER_IF_VOLATILE (td);
                        break;
                case CEE_LDIND_R4:
                        CHECK_STACK (&td, 1);
                        SIMPLE_OP (td, MINT_LDIND_R4);
                        SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_R8);
+                       BARRIER_IF_VOLATILE (td);
                        break;
                case CEE_LDIND_R8:
                        CHECK_STACK (&td, 1);
                        SIMPLE_OP (td, MINT_LDIND_R8);
                        SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_R8);
+                       BARRIER_IF_VOLATILE (td);
                        break;
                case CEE_LDIND_REF:
                        CHECK_STACK (&td, 1);
                        SIMPLE_OP (td, MINT_LDIND_REF);
+                       BARRIER_IF_VOLATILE (td);
                        SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_O);
                        break;
                case CEE_STIND_REF:
                        CHECK_STACK (&td, 2);
+                       BARRIER_IF_VOLATILE (td);
                        SIMPLE_OP (td, MINT_STIND_REF);
                        td.sp -= 2;
                        break;
                case CEE_STIND_I1:
                        CHECK_STACK (&td, 2);
+                       BARRIER_IF_VOLATILE (td);
                        SIMPLE_OP (td, MINT_STIND_I1);
                        td.sp -= 2;
                        break;
                case CEE_STIND_I2:
                        CHECK_STACK (&td, 2);
+                       BARRIER_IF_VOLATILE (td);
                        SIMPLE_OP (td, MINT_STIND_I2);
                        td.sp -= 2;
                        break;
                case CEE_STIND_I4:
                        CHECK_STACK (&td, 2);
+                       BARRIER_IF_VOLATILE (td);
                        SIMPLE_OP (td, MINT_STIND_I4);
                        td.sp -= 2;
                        break;
                case CEE_STIND_I:
                        CHECK_STACK (&td, 2);
+                       BARRIER_IF_VOLATILE (td);
                        SIMPLE_OP (td, MINT_STIND_I);
                        td.sp -= 2;
                        break;
                case CEE_STIND_I8:
                        CHECK_STACK (&td, 2);
+                       BARRIER_IF_VOLATILE (td);
                        SIMPLE_OP (td, MINT_STIND_I8);
                        td.sp -= 2;
                        break;
                case CEE_STIND_R4:
                        CHECK_STACK (&td, 2);
+                       BARRIER_IF_VOLATILE (td);
                        SIMPLE_OP (td, MINT_STIND_R4);
                        td.sp -= 2;
                        break;
                case CEE_STIND_R8:
                        CHECK_STACK (&td, 2);
+                       BARRIER_IF_VOLATILE (td);
                        SIMPLE_OP (td, MINT_STIND_R8);
                        td.sp -= 2;
                        break;
@@ -2381,6 +2415,7 @@ generate (MonoMethod *method, RuntimeMethod *rtm, unsigned char *is_bb_start, Mo
                        }
                        td.ip += 5;
                        SET_TYPE(td.sp - 1, stack_type[mint_type(&klass->byval_arg)], klass);
+                       BARRIER_IF_VOLATILE (td);
                        break;
                }
                case CEE_LDSTR: {
@@ -2598,6 +2633,7 @@ generate (MonoMethod *method, RuntimeMethod *rtm, unsigned char *is_bb_start, Mo
                        }
                        td.ip += 5;
                        SET_TYPE(td.sp - 1, stack_type [mt], field_klass);
+                       BARRIER_IF_VOLATILE (td);
                        break;
                }
                case CEE_STFLD: {
@@ -2608,6 +2644,8 @@ generate (MonoMethod *method, RuntimeMethod *rtm, unsigned char *is_bb_start, Mo
                        mono_class_init (klass);
                        mt = mint_type(field->type);
 
+                       BARRIER_IF_VOLATILE (td);
+
 #ifndef DISABLE_REMOTING
                        if (klass->marshalbyref) {
                                g_assert (!is_static);
@@ -2689,6 +2727,7 @@ generate (MonoMethod *method, RuntimeMethod *rtm, unsigned char *is_bb_start, Mo
                        else
                                klass = mini_get_class (method, token, generic_context);
 
+                       BARRIER_IF_VOLATILE (td);
                        ADD_CODE(&td, td.sp [-1].type == STACK_TYPE_VT ? MINT_STOBJ_VT : MINT_STOBJ);
                        ADD_CODE(&td, get_data_item_index (&td, klass));
                        if (td.sp [-1].type == STACK_TYPE_VT) {
@@ -3534,6 +3573,10 @@ generate (MonoMethod *method, RuntimeMethod *rtm, unsigned char *is_bb_start, Mo
                                PUSH_TYPE (&td, STACK_TYPE_MP, NULL);
                                ++td.ip;
                                break;
+                       case CEE_MONO_MEMORY_BARRIER:
+                               ADD_CODE (&td, MINT_MONO_MEMORY_BARRIER);
+                               ++td.ip;
+                               break;
                        case CEE_MONO_JIT_ATTACH:
                                ADD_CODE (&td, MINT_MONO_JIT_ATTACH);
                                ++td.ip;
@@ -3542,6 +3585,12 @@ generate (MonoMethod *method, RuntimeMethod *rtm, unsigned char *is_bb_start, Mo
                                ADD_CODE (&td, MINT_MONO_JIT_DETACH);
                                ++td.ip;
                                break;
+                       case CEE_MONO_LDDOMAIN:
+                               ADD_CODE (&td, MINT_MONO_LDDOMAIN);
+                               td.sp [0].type = STACK_TYPE_I;
+                               ++td.sp;
+                               ++td.ip;
+                               break;
                        default:
                                g_error ("transform.c: Unimplemented opcode: 0xF0 %02x at 0x%x\n", *td.ip, td.ip-header->code);
                        }
@@ -3693,7 +3742,7 @@ generate (MonoMethod *method, RuntimeMethod *rtm, unsigned char *is_bb_start, Mo
                                break;
                        case CEE_VOLATILE_:
                                ++td.ip;
-                               /* FIX: should do something? */;
+                               volatile_ = TRUE;
                                break;
                        case CEE_TAIL_:
                                ++td.ip;
@@ -3717,7 +3766,10 @@ generate (MonoMethod *method, RuntimeMethod *rtm, unsigned char *is_bb_start, Mo
                        case CEE_CPBLK:
                                CHECK_STACK(&td, 3);
                                /* FIX? convert length to I8? */
+                               if (volatile_)
+                                       ADD_CODE (&td, MINT_MONO_MEMORY_BARRIER);
                                ADD_CODE(&td, MINT_CPBLK);
+                               BARRIER_IF_VOLATILE (td);
                                td.sp -= 3;
                                ++td.ip;
                                break;
@@ -3733,20 +3785,23 @@ generate (MonoMethod *method, RuntimeMethod *rtm, unsigned char *is_bb_start, Mo
                                break;
                        case CEE_INITBLK:
                                CHECK_STACK(&td, 3);
+                               BARRIER_IF_VOLATILE (td);
                                ADD_CODE(&td, MINT_INITBLK);
                                td.sp -= 3;
                                td.ip += 1;
                                break;
-#if 0
                        case CEE_NO_:
                                /* FIXME: implement */
-                               ip += 2;
+                               td.ip += 2;
                                break;
-#endif
-                       case CEE_RETHROW:
+                       case CEE_RETHROW: {
+                               int clause_index = td.clause_indexes [in_offset];
+                               g_assert (clause_index != -1);
                                SIMPLE_OP (td, MINT_RETHROW);
+                               ADD_CODE (&td, rtm->exvar_offsets [clause_index]);
                                generating_code = 0;
                                break;
+                       }
                        case CEE_SIZEOF: {
                                gint32 size;
                                token = read32 (td.ip + 1);
@@ -3877,7 +3932,10 @@ generate (MonoMethod *method, RuntimeMethod *rtm, unsigned char *is_bb_start, Mo
                ei->try_start = (guint8*)(rtm->code + c->try_offset);
                ei->try_end = (guint8*)(rtm->code + c->try_offset + c->try_len);
                ei->handler_start = (guint8*)(rtm->code + c->handler_offset);
-               if (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER || ei->flags == MONO_EXCEPTION_CLAUSE_FINALLY) {
+               ei->exvar_offset = rtm->exvar_offsets [i];
+               if (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER) {
+                       ei->data.filter = (guint8*)(rtm->code + c->data.filter_offset);
+               } else if (ei->flags == MONO_EXCEPTION_CLAUSE_FINALLY) {
                } else {
                        ei->data.catch_class = c->data.catch_class;
                }
@@ -4160,6 +4218,14 @@ mono_interp_transform_method (RuntimeMethod *runtime_method, ThreadContext *cont
                offset += size;
        }
        offset = (offset + 7) & ~7;
+
+       runtime_method->exvar_offsets = g_malloc (header->num_clauses * sizeof (guint32));
+       for (i = 0; i < header->num_clauses; i++) {
+               offset += sizeof (MonoObject*);
+               runtime_method->exvar_offsets [i] = offset;
+       }
+       offset = (offset + 7) & ~7;
+
        runtime_method->locals_size = offset;
        g_assert (runtime_method->locals_size < 65536);
        offset = 0;