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)
{
MonoError error;
int offset, mt, i, i32;
gboolean readonly = FALSE;
+ gboolean volatile_ = FALSE;
MonoClass *klass;
MonoClassField *field;
const unsigned char *end;
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;
}
td.ip += 5;
SET_TYPE(td.sp - 1, stack_type[mint_type(&klass->byval_arg)], klass);
+ BARRIER_IF_VOLATILE (td);
break;
}
case CEE_LDSTR: {
}
td.ip += 5;
SET_TYPE(td.sp - 1, stack_type [mt], field_klass);
+ BARRIER_IF_VOLATILE (td);
break;
}
case CEE_STFLD: {
mono_class_init (klass);
mt = mint_type(field->type);
+ BARRIER_IF_VOLATILE (td);
+
#ifndef DISABLE_REMOTING
if (klass->marshalbyref) {
g_assert (!is_static);
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) {
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;
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);
}
break;
case CEE_VOLATILE_:
++td.ip;
- /* FIX: should do something? */;
+ volatile_ = TRUE;
break;
case CEE_TAIL_:
++td.ip;
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;
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);