projects / mono.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
[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 113a086d3b4a0041f0a5e280d185c9b967abbd08..35592cb05e2bafe26b4b476b9c0925cd962710d5 100644 (file)
--- a/mono/mini/interp/transform.c
+++ b/mono/mini/interp/transform.c
@@ -1329,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)
 {
@@ -1340,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;
@@ -1946,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;
@@ -2387,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: {
@@ -2604,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: {
@@ -2614,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);
@@ -2695,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) {
@@ -3540,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;
@@ -3548,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);
                        }
@@ -3699,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;
@@ -3723,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;
@@ -3739,16 +3785,15 @@ 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: {
                                int clause_index = td.clause_indexes [in_offset];
                                g_assert (clause_index != -1);
my mono mirror. check out Moved to http://github.com/mono/mono