X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Ficall.c;h=e47f958817170c1c735f20615cdd3d391d5a78a4;hb=aea57f09d430ae672e03d96729d447c814ec867c;hp=e91e9e99d2625170e122505c043bfd5226ec5c4d;hpb=39545903866e0a02b28d0a53af2123b7180374ac;p=mono.git diff --git a/mono/metadata/icall.c b/mono/metadata/icall.c index e91e9e99d26..e47f9588171 100644 --- a/mono/metadata/icall.c +++ b/mono/metadata/icall.c @@ -37,7 +37,8 @@ #include #include #include -#include +#include +#include #include #include #include @@ -45,6 +46,7 @@ #include #include #include +#include #include #include #include @@ -63,7 +65,6 @@ #include #include #include -#include #include #include #include @@ -76,8 +77,8 @@ #include #include #include +#include #include -#include #include #include #include @@ -94,9 +95,10 @@ #include #include #endif -#include "decimal.h" +#include "decimal-ms.h" +#include "number-ms.h" -extern MonoString* ves_icall_System_Environment_GetOSVersionString (void) MONO_INTERNAL; +extern MonoString* ves_icall_System_Environment_GetOSVersionString (void); ICALL_EXPORT MonoReflectionAssembly* ves_icall_System_Reflection_Assembly_GetCallingAssembly (void); @@ -116,97 +118,73 @@ mono_class_init_or_throw (MonoClass *klass) mono_raise_exception (mono_class_get_exception_for_failure (klass)); } -/* - * We expect a pointer to a char, not a string - */ -ICALL_EXPORT gboolean -mono_double_ParseImpl (char *ptr, double *result) -{ - gchar *endptr = NULL; - *result = 0.0; - - MONO_ARCH_SAVE_REGS; - - if (*ptr){ - /* mono_strtod () is not thread-safe */ - mono_mutex_lock (&mono_strtod_mutex); - *result = mono_strtod (ptr, &endptr); - mono_mutex_unlock (&mono_strtod_mutex); - } - - if (!*ptr || (endptr && *endptr)) - return FALSE; - - return TRUE; -} - ICALL_EXPORT MonoObject * -ves_icall_System_Array_GetValueImpl (MonoObject *this, guint32 pos) +ves_icall_System_Array_GetValueImpl (MonoArray *arr, guint32 pos) { MonoClass *ac; - MonoArray *ao; gint32 esize; gpointer *ea; - MONO_ARCH_SAVE_REGS; - - ao = (MonoArray *)this; - ac = (MonoClass *)ao->obj.vtable->klass; + ac = (MonoClass *)arr->obj.vtable->klass; esize = mono_array_element_size (ac); - ea = (gpointer*)((char*)ao->vector + (pos * esize)); + ea = (gpointer*)((char*)arr->vector + (pos * esize)); if (ac->element_class->valuetype) - return mono_value_box (this->vtable->domain, ac->element_class, ea); + return mono_value_box (arr->obj.vtable->domain, ac->element_class, ea); else return *ea; } ICALL_EXPORT MonoObject * -ves_icall_System_Array_GetValue (MonoObject *this, MonoObject *idxs) +ves_icall_System_Array_GetValue (MonoArray *arr, MonoArray *idxs) { MonoClass *ac, *ic; - MonoArray *ao, *io; + MonoArray *io; gint32 i, pos, *ind; - MONO_ARCH_SAVE_REGS; + MONO_CHECK_ARG_NULL (idxs, NULL); - MONO_CHECK_ARG_NULL (idxs); - - io = (MonoArray *)idxs; + io = idxs; ic = (MonoClass *)io->obj.vtable->klass; - ao = (MonoArray *)this; - ac = (MonoClass *)ao->obj.vtable->klass; + ac = (MonoClass *)arr->obj.vtable->klass; g_assert (ic->rank == 1); - if (io->bounds != NULL || io->max_length != ac->rank) - mono_raise_exception (mono_get_exception_argument (NULL, NULL)); + if (io->bounds != NULL || io->max_length != ac->rank) { + mono_set_pending_exception (mono_get_exception_argument (NULL, NULL)); + return NULL; + } ind = (gint32 *)io->vector; - if (ao->bounds == NULL) { - if (*ind < 0 || *ind >= ao->max_length) - mono_raise_exception (mono_get_exception_index_out_of_range ()); + if (arr->bounds == NULL) { + if (*ind < 0 || *ind >= arr->max_length) { + mono_set_pending_exception (mono_get_exception_index_out_of_range ()); + return NULL; + } - return ves_icall_System_Array_GetValueImpl (this, *ind); + return ves_icall_System_Array_GetValueImpl (arr, *ind); } - for (i = 0; i < ac->rank; i++) - if ((ind [i] < ao->bounds [i].lower_bound) || - (ind [i] >= (mono_array_lower_bound_t)ao->bounds [i].length + ao->bounds [i].lower_bound)) - mono_raise_exception (mono_get_exception_index_out_of_range ()); + for (i = 0; i < ac->rank; i++) { + if ((ind [i] < arr->bounds [i].lower_bound) || + (ind [i] >= (mono_array_lower_bound_t)arr->bounds [i].length + arr->bounds [i].lower_bound)) { + mono_set_pending_exception (mono_get_exception_index_out_of_range ()); + return NULL; + } + } - pos = ind [0] - ao->bounds [0].lower_bound; + pos = ind [0] - arr->bounds [0].lower_bound; for (i = 1; i < ac->rank; i++) - pos = pos*ao->bounds [i].length + ind [i] - - ao->bounds [i].lower_bound; + pos = pos * arr->bounds [i].length + ind [i] - + arr->bounds [i].lower_bound; - return ves_icall_System_Array_GetValueImpl (this, pos); + return ves_icall_System_Array_GetValueImpl (arr, pos); } ICALL_EXPORT void -ves_icall_System_Array_SetValueImpl (MonoArray *this, MonoObject *value, guint32 pos) +ves_icall_System_Array_SetValueImpl (MonoArray *arr, MonoObject *value, guint32 pos) { MonoClass *ac, *vc, *ec; gint32 esize, vsize; @@ -217,18 +195,16 @@ ves_icall_System_Array_SetValueImpl (MonoArray *this, MonoObject *value, guint32 gint64 i64 = 0; gdouble r64 = 0; - MONO_ARCH_SAVE_REGS; - if (value) vc = value->vtable->klass; else vc = NULL; - ac = this->obj.vtable->klass; + ac = arr->obj.vtable->klass; ec = ac->element_class; esize = mono_array_element_size (ac); - ea = (gpointer*)((char*)this->vector + (pos * esize)); + ea = (gpointer*)((char*)arr->vector + (pos * esize)); va = (gpointer*)((char*)value + sizeof (MonoObject)); if (mono_class_is_nullable (ec)) { @@ -242,19 +218,23 @@ ves_icall_System_Array_SetValueImpl (MonoArray *this, MonoObject *value, guint32 } #define NO_WIDENING_CONVERSION G_STMT_START{\ - mono_raise_exception (mono_get_exception_argument ( \ + mono_set_pending_exception (mono_get_exception_argument ( \ "value", "not a widening conversion")); \ + return; \ }G_STMT_END #define CHECK_WIDENING_CONVERSION(extra) G_STMT_START{\ - if (esize < vsize + (extra)) \ - mono_raise_exception (mono_get_exception_argument ( \ + if (esize < vsize + (extra)) { \ + mono_set_pending_exception (mono_get_exception_argument ( \ "value", "not a widening conversion")); \ + return; \ + } \ }G_STMT_END #define INVALID_CAST G_STMT_START{ \ mono_get_runtime_callbacks ()->set_cast_details (vc, ec); \ - mono_raise_exception (mono_get_exception_invalid_cast ()); \ + mono_set_pending_exception (mono_get_exception_invalid_cast ()); \ + return; \ }G_STMT_END /* Check element (destination) type. */ @@ -287,12 +267,14 @@ ves_icall_System_Array_SetValueImpl (MonoArray *this, MonoObject *value, guint32 INVALID_CAST; } break; + default: + break; } if (!ec->valuetype) { if (!mono_object_isinst (value, ec)) INVALID_CAST; - mono_gc_wbarrier_set_arrayref (this, ea, (MonoObject*)value); + mono_gc_wbarrier_set_arrayref (arr, ea, (MonoObject*)value); return; } @@ -484,44 +466,48 @@ ves_icall_System_Array_SetValueImpl (MonoArray *this, MonoObject *value, guint32 } ICALL_EXPORT void -ves_icall_System_Array_SetValue (MonoArray *this, MonoObject *value, +ves_icall_System_Array_SetValue (MonoArray *arr, MonoObject *value, MonoArray *idxs) { MonoClass *ac, *ic; gint32 i, pos, *ind; - MONO_ARCH_SAVE_REGS; - - MONO_CHECK_ARG_NULL (idxs); + MONO_CHECK_ARG_NULL (idxs,); ic = idxs->obj.vtable->klass; - ac = this->obj.vtable->klass; + ac = arr->obj.vtable->klass; g_assert (ic->rank == 1); - if (idxs->bounds != NULL || idxs->max_length != ac->rank) - mono_raise_exception (mono_get_exception_argument (NULL, NULL)); + if (idxs->bounds != NULL || idxs->max_length != ac->rank) { + mono_set_pending_exception (mono_get_exception_argument (NULL, NULL)); + return; + } ind = (gint32 *)idxs->vector; - if (this->bounds == NULL) { - if (*ind < 0 || *ind >= this->max_length) - mono_raise_exception (mono_get_exception_index_out_of_range ()); + if (arr->bounds == NULL) { + if (*ind < 0 || *ind >= arr->max_length) { + mono_set_pending_exception (mono_get_exception_index_out_of_range ()); + return; + } - ves_icall_System_Array_SetValueImpl (this, value, *ind); + ves_icall_System_Array_SetValueImpl (arr, value, *ind); return; } for (i = 0; i < ac->rank; i++) - if ((ind [i] < this->bounds [i].lower_bound) || - (ind [i] >= (mono_array_lower_bound_t)this->bounds [i].length + this->bounds [i].lower_bound)) - mono_raise_exception (mono_get_exception_index_out_of_range ()); + if ((ind [i] < arr->bounds [i].lower_bound) || + (ind [i] >= (mono_array_lower_bound_t)arr->bounds [i].length + arr->bounds [i].lower_bound)) { + mono_set_pending_exception (mono_get_exception_index_out_of_range ()); + return; + } - pos = ind [0] - this->bounds [0].lower_bound; + pos = ind [0] - arr->bounds [0].lower_bound; for (i = 1; i < ac->rank; i++) - pos = pos * this->bounds [i].length + ind [i] - - this->bounds [i].lower_bound; + pos = pos * arr->bounds [i].length + ind [i] - + arr->bounds [i].lower_bound; - ves_icall_System_Array_SetValueImpl (this, value, pos); + ves_icall_System_Array_SetValueImpl (arr, value, pos); } ICALL_EXPORT MonoArray * @@ -532,18 +518,19 @@ ves_icall_System_Array_CreateInstanceImpl (MonoReflectionType *type, MonoArray * uintptr_t *sizes, i; gboolean bounded = FALSE; - MONO_ARCH_SAVE_REGS; - - MONO_CHECK_ARG_NULL (type); - MONO_CHECK_ARG_NULL (lengths); + MONO_CHECK_ARG_NULL (type, NULL); + MONO_CHECK_ARG_NULL (lengths, NULL); - MONO_CHECK_ARG (lengths, mono_array_length (lengths) > 0); + MONO_CHECK_ARG (lengths, mono_array_length (lengths) > 0, NULL); if (bounds) - MONO_CHECK_ARG (bounds, mono_array_length (lengths) == mono_array_length (bounds)); + MONO_CHECK_ARG (bounds, mono_array_length (lengths) == mono_array_length (bounds), NULL); - for (i = 0; i < mono_array_length (lengths); i++) - if (mono_array_get (lengths, gint32, i) < 0) - mono_raise_exception (mono_get_exception_argument_out_of_range (NULL)); + for (i = 0; i < mono_array_length (lengths); i++) { + if (mono_array_get (lengths, gint32, i) < 0) { + mono_set_pending_exception (mono_get_exception_argument_out_of_range (NULL)); + return NULL; + } + } klass = mono_class_from_mono_type (type->type); mono_class_init_or_throw (klass); @@ -578,19 +565,20 @@ ves_icall_System_Array_CreateInstanceImpl64 (MonoReflectionType *type, MonoArray uintptr_t *sizes, i; gboolean bounded = FALSE; - MONO_ARCH_SAVE_REGS; - - MONO_CHECK_ARG_NULL (type); - MONO_CHECK_ARG_NULL (lengths); + MONO_CHECK_ARG_NULL (type, NULL); + MONO_CHECK_ARG_NULL (lengths, NULL); - MONO_CHECK_ARG (lengths, mono_array_length (lengths) > 0); + MONO_CHECK_ARG (lengths, mono_array_length (lengths) > 0, NULL); if (bounds) - MONO_CHECK_ARG (bounds, mono_array_length (lengths) == mono_array_length (bounds)); + MONO_CHECK_ARG (bounds, mono_array_length (lengths) == mono_array_length (bounds), NULL); - for (i = 0; i < mono_array_length (lengths); i++) + for (i = 0; i < mono_array_length (lengths); i++) { if ((mono_array_get (lengths, gint64, i) < 0) || - (mono_array_get (lengths, gint64, i) > MONO_ARRAY_MAX_INDEX)) - mono_raise_exception (mono_get_exception_argument_out_of_range (NULL)); + (mono_array_get (lengths, gint64, i) > MONO_ARRAY_MAX_INDEX)) { + mono_set_pending_exception (mono_get_exception_argument_out_of_range (NULL)); + return NULL; + } + } klass = mono_class_from_mono_type (type->type); mono_class_init_or_throw (klass); @@ -618,66 +606,66 @@ ves_icall_System_Array_CreateInstanceImpl64 (MonoReflectionType *type, MonoArray } ICALL_EXPORT gint32 -ves_icall_System_Array_GetRank (MonoObject *this) +ves_icall_System_Array_GetRank (MonoObject *arr) { - MONO_ARCH_SAVE_REGS; - - return this->vtable->klass->rank; + return arr->vtable->klass->rank; } ICALL_EXPORT gint32 -ves_icall_System_Array_GetLength (MonoArray *this, gint32 dimension) +ves_icall_System_Array_GetLength (MonoArray *arr, gint32 dimension) { - gint32 rank = ((MonoObject *)this)->vtable->klass->rank; + gint32 rank = arr->obj.vtable->klass->rank; uintptr_t length; - MONO_ARCH_SAVE_REGS; - - if ((dimension < 0) || (dimension >= rank)) - mono_raise_exception (mono_get_exception_index_out_of_range ()); + if ((dimension < 0) || (dimension >= rank)) { + mono_set_pending_exception (mono_get_exception_index_out_of_range ()); + return 0; + } - if (this->bounds == NULL) - length = this->max_length; + if (arr->bounds == NULL) + length = arr->max_length; else - length = this->bounds [dimension].length; + length = arr->bounds [dimension].length; #ifdef MONO_BIG_ARRAYS - if (length > G_MAXINT32) - mono_raise_exception (mono_get_exception_overflow ()); + if (length > G_MAXINT32) { + mono_set_pending_exception (mono_get_exception_overflow ()); + return 0; + } #endif return length; } ICALL_EXPORT gint64 -ves_icall_System_Array_GetLongLength (MonoArray *this, gint32 dimension) +ves_icall_System_Array_GetLongLength (MonoArray *arr, gint32 dimension) { - gint32 rank = ((MonoObject *)this)->vtable->klass->rank; - - MONO_ARCH_SAVE_REGS; + gint32 rank = arr->obj.vtable->klass->rank; - if ((dimension < 0) || (dimension >= rank)) - mono_raise_exception (mono_get_exception_index_out_of_range ()); + if ((dimension < 0) || (dimension >= rank)) { + mono_set_pending_exception (mono_get_exception_index_out_of_range ()); + return 0; + } - if (this->bounds == NULL) - return this->max_length; + if (arr->bounds == NULL) + return arr->max_length; - return this->bounds [dimension].length; + return arr->bounds [dimension].length; } ICALL_EXPORT gint32 -ves_icall_System_Array_GetLowerBound (MonoArray *this, gint32 dimension) +ves_icall_System_Array_GetLowerBound (MonoArray *arr, gint32 dimension) { - gint32 rank = ((MonoObject *)this)->vtable->klass->rank; + gint32 rank = arr->obj.vtable->klass->rank; - MONO_ARCH_SAVE_REGS; - - if ((dimension < 0) || (dimension >= rank)) - mono_raise_exception (mono_get_exception_index_out_of_range ()); + if ((dimension < 0) || (dimension >= rank)) { + mono_set_pending_exception (mono_get_exception_index_out_of_range ()); + return 0; + } - if (this->bounds == NULL) + if (arr->bounds == NULL) return 0; - return this->bounds [dimension].lower_bound; + return arr->bounds [dimension].lower_bound; } ICALL_EXPORT void @@ -752,40 +740,32 @@ ves_icall_System_Array_FastCopy (MonoArray *source, int source_idx, MonoArray* d } ICALL_EXPORT void -ves_icall_System_Array_GetGenericValueImpl (MonoObject *this, guint32 pos, gpointer value) +ves_icall_System_Array_GetGenericValueImpl (MonoArray *arr, guint32 pos, gpointer value) { MonoClass *ac; - MonoArray *ao; gint32 esize; gpointer *ea; - MONO_ARCH_SAVE_REGS; - - ao = (MonoArray *)this; - ac = (MonoClass *)ao->obj.vtable->klass; + ac = (MonoClass *)arr->obj.vtable->klass; esize = mono_array_element_size (ac); - ea = (gpointer*)((char*)ao->vector + (pos * esize)); + ea = (gpointer*)((char*)arr->vector + (pos * esize)); mono_gc_memmove_atomic (value, ea, esize); } ICALL_EXPORT void -ves_icall_System_Array_SetGenericValueImpl (MonoObject *this, guint32 pos, gpointer value) +ves_icall_System_Array_SetGenericValueImpl (MonoArray *arr, guint32 pos, gpointer value) { MonoClass *ac, *ec; - MonoArray *ao; gint32 esize; gpointer *ea; - MONO_ARCH_SAVE_REGS; - - ao = (MonoArray *)this; - ac = (MonoClass *)ao->obj.vtable->klass; + ac = (MonoClass *)arr->obj.vtable->klass; ec = ac->element_class; esize = mono_array_element_size (ac); - ea = (gpointer*)((char*)ao->vector + (pos * esize)); + ea = (gpointer*)((char*)arr->vector + (pos * esize)); if (MONO_TYPE_IS_REFERENCE (&ec->byval_arg)) { g_assert (esize == sizeof (gpointer)); @@ -812,13 +792,15 @@ ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray (MonoAr if (MONO_TYPE_IS_REFERENCE (type) || type->type == MONO_TYPE_VALUETYPE) { MonoException *exc = mono_get_exception_argument("array", "Cannot initialize array of non-primitive type."); - mono_raise_exception (exc); + mono_set_pending_exception (exc); + return; } if (!(field_handle->type->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA)) { MonoException *exc = mono_get_exception_argument("field_handle", "Field doesn't have an RVA"); - mono_raise_exception (exc); + mono_set_pending_exception (exc); + return; } size *= array->max_length; @@ -827,7 +809,8 @@ ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray (MonoAr if (size > mono_type_size (field_handle->type, &align)) { MonoException *exc = mono_get_exception_argument("field_handle", "Field not large enough to fill array"); - mono_raise_exception (exc); + mono_set_pending_exception (exc); + return; } #if G_BYTE_ORDER != G_LITTLE_ENDIAN @@ -871,16 +854,12 @@ ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray (MonoAr ICALL_EXPORT gint ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetOffsetToStringData (void) { - MONO_ARCH_SAVE_REGS; - return offsetof (MonoString, chars); } ICALL_EXPORT MonoObject * ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetObjectValue (MonoObject *obj) { - MONO_ARCH_SAVE_REGS; - if ((obj == NULL) || (! (obj->vtable->klass->valuetype))) return obj; else @@ -893,10 +872,10 @@ ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunClassConstructor (Mo MonoClass *klass; MonoVTable *vtable; - MONO_CHECK_ARG_NULL (handle); + MONO_CHECK_ARG_NULL (handle,); klass = mono_class_from_mono_type (handle); - MONO_CHECK_ARG (handle, klass); + MONO_CHECK_ARG (handle, klass,); vtable = mono_class_vtable_full (mono_domain_get (), klass, TRUE); @@ -947,15 +926,13 @@ ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_SufficientExecutionStac } ICALL_EXPORT MonoObject * -ves_icall_System_Object_MemberwiseClone (MonoObject *this) +ves_icall_System_Object_MemberwiseClone (MonoObject *this_obj) { - MONO_ARCH_SAVE_REGS; - - return mono_object_clone (this); + return mono_object_clone (this_obj); } ICALL_EXPORT gint32 -ves_icall_System_ValueType_InternalGetHashCode (MonoObject *this, MonoArray **fields) +ves_icall_System_ValueType_InternalGetHashCode (MonoObject *this_obj, MonoArray **fields) { MonoClass *klass; MonoObject **values = NULL; @@ -965,9 +942,7 @@ ves_icall_System_ValueType_InternalGetHashCode (MonoObject *this, MonoArray **fi MonoClassField* field; gpointer iter; - MONO_ARCH_SAVE_REGS; - - klass = mono_object_class (this); + klass = mono_object_class (this_obj); if (mono_class_num_fields (klass) == 0) return result; @@ -986,11 +961,11 @@ ves_icall_System_ValueType_InternalGetHashCode (MonoObject *this, MonoArray **fi /* FIXME: Add more types */ switch (field->type->type) { case MONO_TYPE_I4: - result ^= *(gint32*)((guint8*)this + field->offset); + result ^= *(gint32*)((guint8*)this_obj + field->offset); break; case MONO_TYPE_STRING: { MonoString *s; - s = *(MonoString**)((guint8*)this + field->offset); + s = *(MonoString**)((guint8*)this_obj + field->offset); if (s != NULL) result ^= mono_string_hash (s); break; @@ -998,7 +973,7 @@ ves_icall_System_ValueType_InternalGetHashCode (MonoObject *this, MonoArray **fi default: if (!values) values = g_newa (MonoObject*, mono_class_num_fields (klass)); - o = mono_field_get_value_object (mono_object_domain (this), field, this); + o = mono_field_get_value_object (mono_object_domain (this_obj), field, this_obj); values [count++] = o; } } @@ -1015,7 +990,7 @@ ves_icall_System_ValueType_InternalGetHashCode (MonoObject *this, MonoArray **fi } ICALL_EXPORT MonoBoolean -ves_icall_System_ValueType_Equals (MonoObject *this, MonoObject *that, MonoArray **fields) +ves_icall_System_ValueType_Equals (MonoObject *this_obj, MonoObject *that, MonoArray **fields) { MonoClass *klass; MonoObject **values = NULL; @@ -1024,17 +999,15 @@ ves_icall_System_ValueType_Equals (MonoObject *this, MonoObject *that, MonoArray gpointer iter; int count = 0; - MONO_ARCH_SAVE_REGS; - - MONO_CHECK_ARG_NULL (that); + MONO_CHECK_ARG_NULL (that, FALSE); - if (this->vtable != that->vtable) + if (this_obj->vtable != that->vtable) return FALSE; - klass = mono_object_class (this); + klass = mono_object_class (this_obj); if (klass->enumtype && mono_class_enum_basetype (klass) && mono_class_enum_basetype (klass)->type == MONO_TYPE_I4) - return (*(gint32*)((guint8*)this + sizeof (MonoObject)) == *(gint32*)((guint8*)that + sizeof (MonoObject))); + return (*(gint32*)((guint8*)this_obj + sizeof (MonoObject)) == *(gint32*)((guint8*)that + sizeof (MonoObject))); /* * Do the comparison for fields of primitive type and return a result if @@ -1054,31 +1027,31 @@ ves_icall_System_ValueType_Equals (MonoObject *this, MonoObject *that, MonoArray case MONO_TYPE_U1: case MONO_TYPE_I1: case MONO_TYPE_BOOLEAN: - if (*((guint8*)this + field->offset) != *((guint8*)that + field->offset)) + if (*((guint8*)this_obj + field->offset) != *((guint8*)that + field->offset)) return FALSE; break; case MONO_TYPE_U2: case MONO_TYPE_I2: case MONO_TYPE_CHAR: - if (*(gint16*)((guint8*)this + field->offset) != *(gint16*)((guint8*)that + field->offset)) + if (*(gint16*)((guint8*)this_obj + field->offset) != *(gint16*)((guint8*)that + field->offset)) return FALSE; break; case MONO_TYPE_U4: case MONO_TYPE_I4: - if (*(gint32*)((guint8*)this + field->offset) != *(gint32*)((guint8*)that + field->offset)) + if (*(gint32*)((guint8*)this_obj + field->offset) != *(gint32*)((guint8*)that + field->offset)) return FALSE; break; case MONO_TYPE_U8: case MONO_TYPE_I8: - if (*(gint64*)((guint8*)this + field->offset) != *(gint64*)((guint8*)that + field->offset)) + if (*(gint64*)((guint8*)this_obj + field->offset) != *(gint64*)((guint8*)that + field->offset)) return FALSE; break; case MONO_TYPE_R4: - if (*(float*)((guint8*)this + field->offset) != *(float*)((guint8*)that + field->offset)) + if (*(float*)((guint8*)this_obj + field->offset) != *(float*)((guint8*)that + field->offset)) return FALSE; break; case MONO_TYPE_R8: - if (*(double*)((guint8*)this + field->offset) != *(double*)((guint8*)that + field->offset)) + if (*(double*)((guint8*)this_obj + field->offset) != *(double*)((guint8*)that + field->offset)) return FALSE; break; @@ -1086,7 +1059,7 @@ ves_icall_System_ValueType_Equals (MonoObject *this, MonoObject *that, MonoArray case MONO_TYPE_STRING: { MonoString *s1, *s2; guint32 s1len, s2len; - s1 = *(MonoString**)((guint8*)this + field->offset); + s1 = *(MonoString**)((guint8*)this_obj + field->offset); s2 = *(MonoString**)((guint8*)that + field->offset); if (s1 == s2) break; @@ -1104,9 +1077,9 @@ ves_icall_System_ValueType_Equals (MonoObject *this, MonoObject *that, MonoArray default: if (!values) values = g_newa (MonoObject*, mono_class_num_fields (klass) * 2); - o = mono_field_get_value_object (mono_object_domain (this), field, this); + o = mono_field_get_value_object (mono_object_domain (this_obj), field, this_obj); values [count++] = o; - o = mono_field_get_value_object (mono_object_domain (this), field, that); + o = mono_field_get_value_object (mono_object_domain (this_obj), field, that); values [count++] = o; } @@ -1129,8 +1102,6 @@ ves_icall_System_ValueType_Equals (MonoObject *this, MonoObject *that, MonoArray ICALL_EXPORT MonoReflectionType * ves_icall_System_Object_GetType (MonoObject *obj) { - MONO_ARCH_SAVE_REGS; - #ifndef DISABLE_REMOTING if (obj->vtable->klass == mono_defaults.transparent_proxy_class) return mono_type_get_object (mono_object_domain (obj), &((MonoTransparentProxy*)obj)->remote_class->proxy_class->byval_arg); @@ -1142,8 +1113,6 @@ ves_icall_System_Object_GetType (MonoObject *obj) ICALL_EXPORT void mono_type_type_from_obj (MonoReflectionType *mtype, MonoObject *obj) { - MONO_ARCH_SAVE_REGS; - mtype->type = &obj->vtable->klass->byval_arg; g_assert (mtype->type->type); } @@ -1151,9 +1120,7 @@ mono_type_type_from_obj (MonoReflectionType *mtype, MonoObject *obj) ICALL_EXPORT gint32 ves_icall_ModuleBuilder_getToken (MonoReflectionModuleBuilder *mb, MonoObject *obj, gboolean create_open_instance) { - MONO_ARCH_SAVE_REGS; - - MONO_CHECK_ARG_NULL (obj); + MONO_CHECK_ARG_NULL (obj, 0); return mono_image_create_token (mb->dynamic_image, obj, create_open_instance, TRUE); } @@ -1163,9 +1130,7 @@ ves_icall_ModuleBuilder_getMethodToken (MonoReflectionModuleBuilder *mb, MonoReflectionMethod *method, MonoArray *opt_param_types) { - MONO_ARCH_SAVE_REGS; - - MONO_CHECK_ARG_NULL (method); + MONO_CHECK_ARG_NULL (method, 0); return mono_image_create_method_token ( mb->dynamic_image, (MonoObject *) method, opt_param_types); @@ -1174,27 +1139,33 @@ ves_icall_ModuleBuilder_getMethodToken (MonoReflectionModuleBuilder *mb, ICALL_EXPORT void ves_icall_ModuleBuilder_WriteToFile (MonoReflectionModuleBuilder *mb, HANDLE file) { - MONO_ARCH_SAVE_REGS; - mono_image_create_pefile (mb, file); } ICALL_EXPORT void ves_icall_ModuleBuilder_build_metadata (MonoReflectionModuleBuilder *mb) { - MONO_ARCH_SAVE_REGS; - mono_image_build_metadata (mb); } ICALL_EXPORT void ves_icall_ModuleBuilder_RegisterToken (MonoReflectionModuleBuilder *mb, MonoObject *obj, guint32 token) { - MONO_ARCH_SAVE_REGS; - mono_image_register_token (mb->dynamic_image, token, obj); } +ICALL_EXPORT MonoObject* +ves_icall_ModuleBuilder_GetRegisteredToken (MonoReflectionModuleBuilder *mb, guint32 token) +{ + gpointer obj; + + mono_loader_lock (); + obj = mono_g_hash_table_lookup (mb->dynamic_image->tokens, GUINT_TO_POINTER (token)); + mono_loader_unlock (); + + return obj; +} + static gboolean get_caller (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data) { @@ -1270,8 +1241,6 @@ type_from_name (const char *str, MonoBoolean ignoreCase) char *temp_str = g_strdup (str); gboolean type_resolve = FALSE; - MONO_ARCH_SAVE_REGS; - /* mono_reflection_parse_type() mangles the string */ if (!mono_reflection_parse_type (temp_str, &info)) { mono_reflection_free_type_info (&info); @@ -1362,8 +1331,10 @@ ves_icall_type_from_name (MonoString *name, e = mono_get_exception_type_load (name, NULL); mono_loader_clear_error (); - if (e != NULL) - mono_raise_exception (e); + if (e) { + mono_set_pending_exception (e); + return NULL; + } } return type; @@ -1375,22 +1346,9 @@ ves_icall_type_from_handle (MonoType *handle) { MonoDomain *domain = mono_domain_get (); - MONO_ARCH_SAVE_REGS; - return mono_type_get_object (domain, handle); } -ICALL_EXPORT MonoBoolean -ves_icall_System_Type_EqualsInternal (MonoReflectionType *type, MonoReflectionType *c) -{ - MONO_ARCH_SAVE_REGS; - - if (c && type->type && c->type) - return mono_metadata_type_equal (type->type, c->type); - else - return (type == c) ? TRUE : FALSE; -} - /* System.TypeCode */ typedef enum { TYPECODE_EMPTY, @@ -1418,8 +1376,6 @@ ves_icall_type_GetTypeCodeInternal (MonoReflectionType *type) { int t = type->type->type; - MONO_ARCH_SAVE_REGS; - if (type->type->byref) return TYPECODE_OBJECT; @@ -1497,42 +1453,6 @@ handle_enum: return 0; } -ICALL_EXPORT guint32 -ves_icall_type_is_subtype_of (MonoReflectionType *type, MonoReflectionType *c, MonoBoolean check_interfaces) -{ - MonoDomain *domain; - MonoClass *klass; - MonoClass *klassc; - - MONO_ARCH_SAVE_REGS; - - g_assert (type != NULL); - - domain = ((MonoObject *)type)->vtable->domain; - - if (!c) /* FIXME: dont know what do do here */ - return 0; - - klass = mono_class_from_mono_type (type->type); - klassc = mono_class_from_mono_type (c->type); - - /* Interface check requires a more complex setup so we - * only do for them. Otherwise we simply avoid mono_class_init. - */ - if (check_interfaces) { - mono_class_init_or_throw (klass); - mono_class_init_or_throw (klassc); - } else if (!klass->supertypes || !klassc->supertypes) { - mono_class_setup_supertypes (klass); - mono_class_setup_supertypes (klassc); - } - - if (type->type->byref) - return klassc == mono_defaults.object_class; - - return mono_class_is_subclass_of (klass, klassc, check_interfaces); -} - static gboolean mono_type_is_primitive (MonoType *type) { @@ -1553,16 +1473,11 @@ mono_type_get_underlying_type_ignore_byref (MonoType *type) ICALL_EXPORT guint32 ves_icall_type_is_assignable_from (MonoReflectionType *type, MonoReflectionType *c) { - MonoDomain *domain; MonoClass *klass; MonoClass *klassc; - MONO_ARCH_SAVE_REGS; - g_assert (type != NULL); - domain = ((MonoObject *)type)->vtable->domain; - klass = mono_class_from_mono_type (type->type); klassc = mono_class_from_mono_type (c->type); @@ -1691,7 +1606,6 @@ ves_icall_get_method_info (MonoMethod *method, MonoMethodInfo *info) MonoError error; MonoDomain *domain = mono_domain_get (); MonoMethodSignature* sig; - MONO_ARCH_SAVE_REGS; sig = mono_method_signature_checked (method, &error); if (!mono_error_ok (&error)) @@ -1758,7 +1672,6 @@ ICALL_EXPORT MonoReflectionType* ves_icall_MonoField_GetParentType (MonoReflectionField *field, MonoBoolean declaring) { MonoClass *parent; - MONO_ARCH_SAVE_REGS; parent = declaring? field->field->parent: field->klass; @@ -1772,9 +1685,11 @@ ves_icall_MonoField_GetValueInternal (MonoReflectionField *field, MonoObject *ob MonoClassField *cf = field->field; MonoDomain *domain = mono_object_domain (field); - if (fklass->image->assembly->ref_only) - mono_raise_exception (mono_get_exception_invalid_operation ( + if (fklass->image->assembly->ref_only) { + mono_set_pending_exception (mono_get_exception_invalid_operation ( "It is illegal to get the value on a field on a type loaded using the ReflectionOnly methods.")); + return NULL; + } if (mono_security_core_clr_enabled ()) mono_security_core_clr_ensure_reflection_access_field (cf); @@ -1790,11 +1705,11 @@ ves_icall_MonoField_SetValueInternal (MonoReflectionField *field, MonoObject *ob MonoType *type; gchar *v; - MONO_ARCH_SAVE_REGS; - - if (field->klass->image->assembly->ref_only) - mono_raise_exception (mono_get_exception_invalid_operation ( + if (field->klass->image->assembly->ref_only) { + mono_set_pending_exception (mono_get_exception_invalid_operation ( "It is illegal to set the value on a field on a type loaded using the ReflectionOnly methods.")); + return; + } if (mono_security_core_clr_enabled ()) mono_security_core_clr_ensure_reflection_access_field (cf); @@ -1873,39 +1788,73 @@ ves_icall_MonoField_SetValueInternal (MonoReflectionField *field, MonoObject *ob } } +ICALL_EXPORT void +ves_icall_System_RuntimeFieldHandle_SetValueDirect (MonoReflectionField *field, MonoReflectionType *field_type, MonoTypedRef *obj, MonoObject *value, MonoReflectionType *context_type) +{ + MonoClassField *f; + + g_assert (field); + g_assert (obj); + g_assert (value); + + f = field->field; + if (!MONO_TYPE_ISSTRUCT (&f->parent->byval_arg)) { + mono_set_pending_exception (mono_get_exception_not_implemented (NULL)); + return; + } + + if (MONO_TYPE_IS_REFERENCE (f->type)) + mono_copy_value (f->type, (guint8*)obj->value + f->offset - sizeof (MonoObject), value, FALSE); + else + mono_copy_value (f->type, (guint8*)obj->value + f->offset - sizeof (MonoObject), mono_object_unbox (value), FALSE); +} + ICALL_EXPORT MonoObject * -ves_icall_MonoField_GetRawConstantValue (MonoReflectionField *this) +ves_icall_MonoField_GetRawConstantValue (MonoReflectionField *rfield) { MonoObject *o = NULL; - MonoClassField *field = this->field; + MonoClassField *field = rfield->field; MonoClass *klass; - MonoDomain *domain = mono_object_domain (this); + MonoDomain *domain = mono_object_domain (rfield); gchar *v; MonoTypeEnum def_type; const char *def_value; MonoType *t; MonoError error; - MONO_ARCH_SAVE_REGS; - mono_class_init (field->parent); t = mono_field_get_type_checked (field, &error); if (!mono_error_ok (&error)) mono_error_raise_exception (&error); - if (!(t->attrs & FIELD_ATTRIBUTE_HAS_DEFAULT)) - mono_raise_exception (mono_get_exception_invalid_operation (NULL)); + if (!(t->attrs & FIELD_ATTRIBUTE_HAS_DEFAULT)) { + mono_set_pending_exception (mono_get_exception_invalid_operation (NULL)); + return NULL; + } if (image_is_dynamic (field->parent->image)) { - /* FIXME: */ - g_assert_not_reached (); + MonoClass *klass = field->parent; + int fidx = field - klass->fields; + + g_assert (fidx >= 0 && fidx < klass->field.count); + g_assert (klass->ext); + g_assert (klass->ext->field_def_values); + def_type = klass->ext->field_def_values [fidx].def_type; + def_value = klass->ext->field_def_values [fidx].data; + if (def_type == MONO_TYPE_END) { + mono_set_pending_exception (mono_get_exception_invalid_operation (NULL)); + return NULL; + } + } else { + def_value = mono_class_get_field_default_value (field, &def_type); + /* FIXME, maybe we should try to raise TLE if field->parent is broken */ + if (!def_value) { + mono_set_pending_exception (mono_get_exception_invalid_operation (NULL)); + return NULL; + } } - def_value = mono_class_get_field_default_value (field, &def_type); - if (!def_value) /*FIXME, maybe we should try to raise TLE if field->parent is broken */ - mono_raise_exception (mono_get_exception_invalid_operation (NULL)); - /*FIXME unify this with reflection.c:mono_get_object_from_blob*/ switch (def_type) { case MONO_TYPE_U1: @@ -1975,30 +1924,30 @@ typedef enum { } PInfo; ICALL_EXPORT void -ves_icall_get_property_info (MonoReflectionProperty *property, MonoPropertyInfo *info, PInfo req_info) +ves_icall_get_property_info (const MonoReflectionProperty *property, MonoPropertyInfo *info, PInfo req_info) { MonoDomain *domain = mono_object_domain (property); - - MONO_ARCH_SAVE_REGS; + const MonoProperty *pproperty = property->property; if ((req_info & PInfo_ReflectedType) != 0) MONO_STRUCT_SETREF (info, parent, mono_type_get_object (domain, &property->klass->byval_arg)); if ((req_info & PInfo_DeclaringType) != 0) - MONO_STRUCT_SETREF (info, declaring_type, mono_type_get_object (domain, &property->property->parent->byval_arg)); + MONO_STRUCT_SETREF (info, declaring_type, mono_type_get_object (domain, &pproperty->parent->byval_arg)); if ((req_info & PInfo_Name) != 0) - MONO_STRUCT_SETREF (info, name, mono_string_new (domain, property->property->name)); + MONO_STRUCT_SETREF (info, name, mono_string_new (domain, pproperty->name)); if ((req_info & PInfo_Attributes) != 0) - info->attrs = property->property->attrs; + info->attrs = pproperty->attrs; if ((req_info & PInfo_GetMethod) != 0) - MONO_STRUCT_SETREF (info, get, property->property->get ? - mono_method_get_object (domain, property->property->get, property->klass): NULL); - + MONO_STRUCT_SETREF (info, get, pproperty->get && + (((pproperty->get->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) != METHOD_ATTRIBUTE_PRIVATE) || pproperty->get->klass == property->klass) ? + mono_method_get_object (domain, pproperty->get, property->klass): NULL); if ((req_info & PInfo_SetMethod) != 0) - MONO_STRUCT_SETREF (info, set, property->property->set ? - mono_method_get_object (domain, property->property->set, property->klass): NULL); + MONO_STRUCT_SETREF (info, set, pproperty->set && + (((pproperty->set->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) != METHOD_ATTRIBUTE_PRIVATE) || pproperty->set->klass == property->klass) ? + mono_method_get_object (domain, pproperty->set, property->klass): NULL); /* * There may be other methods defined for properties, though, it seems they are not exposed * in the reflection API @@ -2010,8 +1959,6 @@ ves_icall_get_event_info (MonoReflectionMonoEvent *event, MonoEventInfo *info) { MonoDomain *domain = mono_object_domain (event); - MONO_ARCH_SAVE_REGS; - MONO_STRUCT_SETREF (info, reflected_type, mono_type_get_object (domain, &event->klass->byval_arg)); MONO_STRUCT_SETREF (info, declaring_type, mono_type_get_object (domain, &event->event->parent->byval_arg)); @@ -2084,6 +2031,14 @@ fill_iface_array (gpointer key, gpointer value, gpointer user_data) mono_metadata_free_type (inflated); } +static guint +get_interfaces_hash (gconstpointer v1) +{ + MonoClass *k = (MonoClass*)v1; + + return k->type_token; +} + ICALL_EXPORT MonoArray* ves_icall_Type_GetInterfaces (MonoReflectionType* type) { @@ -2093,7 +2048,7 @@ ves_icall_Type_GetInterfaces (MonoReflectionType* type) FillIfaceArrayData data = { 0 }; int len; - GHashTable *iface_hash = g_hash_table_new (NULL, NULL); + GHashTable *iface_hash = g_hash_table_new (get_interfaces_hash, NULL); if (class->generic_class && class->generic_class->context.class_inst->is_open) { data.context = mono_class_get_context (class); @@ -2146,7 +2101,6 @@ ves_icall_Type_GetInterfaceMapData (MonoReflectionType *type, MonoReflectionType int i = 0, len, ioffset; MonoDomain *domain; - MONO_ARCH_SAVE_REGS; mono_class_init_or_throw (class); mono_class_init_or_throw (iclass); @@ -2191,8 +2145,6 @@ ves_icall_MonoType_GetElementType (MonoReflectionType *type) { MonoClass *class; - MONO_ARCH_SAVE_REGS; - if (!type->type->byref && type->type->type == MONO_TYPE_SZARRAY) return mono_type_get_object (mono_object_domain (type), &type->type->data.klass->byval_arg); @@ -2214,6 +2166,9 @@ ves_icall_MonoType_GetElementType (MonoReflectionType *type) ICALL_EXPORT MonoReflectionType* ves_icall_get_type_parent (MonoReflectionType *type) { + if (type->type->byref) + return NULL; + MonoClass *class = mono_class_from_mono_type (type->type); return class->parent ? mono_type_get_object (mono_object_domain (type), &class->parent->byval_arg): NULL; } @@ -2221,24 +2176,18 @@ ves_icall_get_type_parent (MonoReflectionType *type) ICALL_EXPORT MonoBoolean ves_icall_type_ispointer (MonoReflectionType *type) { - MONO_ARCH_SAVE_REGS; - return type->type->type == MONO_TYPE_PTR; } ICALL_EXPORT MonoBoolean ves_icall_type_isprimitive (MonoReflectionType *type) { - MONO_ARCH_SAVE_REGS; - return (!type->type->byref && (((type->type->type >= MONO_TYPE_BOOLEAN) && (type->type->type <= MONO_TYPE_R8)) || (type->type->type == MONO_TYPE_I) || (type->type->type == MONO_TYPE_U))); } ICALL_EXPORT MonoBoolean ves_icall_type_isbyref (MonoReflectionType *type) { - MONO_ARCH_SAVE_REGS; - return type->type->byref; } @@ -2272,8 +2221,6 @@ ves_icall_MonoType_get_DeclaringType (MonoReflectionType *type) MonoDomain *domain = mono_domain_get (); MonoClass *class; - MONO_ARCH_SAVE_REGS; - if (type->type->byref) return NULL; if (type->type->type == MONO_TYPE_VAR) { @@ -2327,40 +2274,48 @@ ves_icall_MonoType_GetArrayRank (MonoReflectionType *type) { MonoClass *class; - if (type->type->type != MONO_TYPE_ARRAY && type->type->type != MONO_TYPE_SZARRAY) - mono_raise_exception (mono_get_exception_argument ("type", "Type must be an array type")); + if (type->type->type != MONO_TYPE_ARRAY && type->type->type != MONO_TYPE_SZARRAY) { + mono_set_pending_exception (mono_get_exception_argument ("type", "Type must be an array type")); + return 0; + } class = mono_class_from_mono_type (type->type); return class->rank; } +static MonoArray* +create_type_array (MonoDomain *domain, MonoBoolean runtimeTypeArray, int count) +{ + MonoArray *res; + res = mono_array_new (domain, runtimeTypeArray ? mono_defaults.runtimetype_class : mono_defaults.systemtype_class, count); + return res; +} + ICALL_EXPORT MonoArray* -ves_icall_MonoType_GetGenericArguments (MonoReflectionType *type) +ves_icall_MonoType_GetGenericArguments (MonoReflectionType *type, MonoBoolean runtimeTypeArray) { MonoArray *res; MonoClass *klass, *pklass; MonoDomain *domain = mono_object_domain (type); - MonoVTable *array_vtable = mono_class_vtable_full (domain, mono_array_class_get_cached (mono_defaults.systemtype_class, 1), TRUE); int i; - MONO_ARCH_SAVE_REGS; klass = mono_class_from_mono_type (type->type); if (klass->generic_container) { MonoGenericContainer *container = klass->generic_container; - res = mono_array_new_specific (array_vtable, container->type_argc); + res = create_type_array (domain, runtimeTypeArray, container->type_argc); for (i = 0; i < container->type_argc; ++i) { pklass = mono_class_from_generic_parameter (mono_generic_container_get_param (container, i), klass->image, FALSE); mono_array_setref (res, i, mono_type_get_object (domain, &pklass->byval_arg)); } } else if (klass->generic_class) { MonoGenericInst *inst = klass->generic_class->context.class_inst; - res = mono_array_new_specific (array_vtable, inst->type_argc); + res = create_type_array (domain, runtimeTypeArray, inst->type_argc); for (i = 0; i < inst->type_argc; ++i) mono_array_setref (res, i, mono_type_get_object (domain, inst->type_argv [i])); } else { - res = mono_array_new_specific (array_vtable, 0); + res = NULL; } return res; } @@ -2369,7 +2324,6 @@ ICALL_EXPORT gboolean ves_icall_Type_get_IsGenericTypeDefinition (MonoReflectionType *type) { MonoClass *klass; - MONO_ARCH_SAVE_REGS; if (!IS_MONOTYPE (type)) return FALSE; @@ -2385,7 +2339,6 @@ ICALL_EXPORT MonoReflectionType* ves_icall_Type_GetGenericTypeDefinition_impl (MonoReflectionType *type) { MonoClass *klass; - MONO_ARCH_SAVE_REGS; if (type->type->byref) return NULL; @@ -2435,31 +2388,18 @@ ves_icall_Type_MakeGenericType (MonoReflectionType *type, MonoArray *type_array) class = mono_class_from_mono_type (geninst); /*we might inflate to the GTD*/ - if (class->generic_class && !mono_verifier_class_is_valid_generic_instantiation (class)) - mono_raise_exception (mono_get_exception_argument ("typeArguments", "Invalid generic arguments")); + if (class->generic_class && !mono_verifier_class_is_valid_generic_instantiation (class)) { + mono_set_pending_exception (mono_get_exception_argument ("typeArguments", "Invalid generic arguments")); + return NULL; + } return mono_type_get_object (mono_object_domain (type), geninst); } -ICALL_EXPORT gboolean -ves_icall_Type_get_IsGenericInstance (MonoReflectionType *type) -{ - MonoClass *klass; - MONO_ARCH_SAVE_REGS; - - if (type->type->byref) - return FALSE; - - klass = mono_class_from_mono_type (type->type); - - return klass->generic_class != NULL; -} - ICALL_EXPORT gboolean ves_icall_Type_get_IsGenericType (MonoReflectionType *type) { MonoClass *klass; - MONO_ARCH_SAVE_REGS; if (!IS_MONOTYPE (type)) return FALSE; @@ -2474,8 +2414,6 @@ ves_icall_Type_get_IsGenericType (MonoReflectionType *type) ICALL_EXPORT gint32 ves_icall_Type_GetGenericParameterPosition (MonoReflectionType *type) { - MONO_ARCH_SAVE_REGS; - if (!IS_MONOTYPE (type)) return -1; @@ -2487,8 +2425,6 @@ ves_icall_Type_GetGenericParameterPosition (MonoReflectionType *type) ICALL_EXPORT GenericParameterAttributes ves_icall_Type_GetGenericParameterAttributes (MonoReflectionType *type) { - MONO_ARCH_SAVE_REGS; - g_assert (IS_MONOTYPE (type)); g_assert (is_generic_parameter (type->type)); return mono_generic_param_info (type->type->data.generic_param)->flags; @@ -2503,8 +2439,6 @@ ves_icall_Type_GetGenericParameterConstraints (MonoReflectionType *type) MonoArray *res; int i, count; - MONO_ARCH_SAVE_REGS; - g_assert (IS_MONOTYPE (type)); domain = mono_object_domain (type); @@ -2523,14 +2457,12 @@ ves_icall_Type_GetGenericParameterConstraints (MonoReflectionType *type) ICALL_EXPORT MonoBoolean ves_icall_MonoType_get_IsGenericParameter (MonoReflectionType *type) { - MONO_ARCH_SAVE_REGS; return is_generic_parameter (type->type); } ICALL_EXPORT MonoBoolean ves_icall_TypeBuilder_get_IsGenericParameter (MonoReflectionTypeBuilder *tb) { - MONO_ARCH_SAVE_REGS; return is_generic_parameter (tb->type.type); } @@ -2550,8 +2482,6 @@ ves_icall_MonoType_GetCorrespondingInflatedMethod (MonoReflectionType *type, MonoMethod *method; gpointer iter; - MONO_ARCH_SAVE_REGS; - domain = ((MonoObject *)type)->vtable->domain; klass = mono_class_from_mono_type (type->type); @@ -2566,18 +2496,16 @@ ves_icall_MonoType_GetCorrespondingInflatedMethod (MonoReflectionType *type, return NULL; } - - ICALL_EXPORT MonoReflectionMethod * ves_icall_MonoType_get_DeclaringMethod (MonoReflectionType *ref_type) { MonoMethod *method; MonoType *type = ref_type->type; - MONO_ARCH_SAVE_REGS; - - if (type->byref || (type->type != MONO_TYPE_MVAR && type->type != MONO_TYPE_VAR)) - mono_raise_exception (mono_get_exception_invalid_operation ("DeclaringMethod can only be used on generic arguments")); + if (type->byref || (type->type != MONO_TYPE_MVAR && type->type != MONO_TYPE_VAR)) { + mono_set_pending_exception (mono_get_exception_invalid_operation ("DeclaringMethod can only be used on generic arguments")); + return NULL; + } if (type->type == MONO_TYPE_VAR) return NULL; @@ -2586,14 +2514,26 @@ ves_icall_MonoType_get_DeclaringMethod (MonoReflectionType *ref_type) return mono_method_get_object (mono_object_domain (ref_type), method, method->klass); } -ICALL_EXPORT MonoReflectionDllImportAttribute* -ves_icall_MonoMethod_GetDllImportAttribute (MonoMethod *method) +ICALL_EXPORT MonoBoolean +ves_icall_System_RuntimeType_IsTypeExportedToWindowsRuntime (void) +{ + mono_set_pending_exception (mono_get_exception_not_implemented (NULL)); + return FALSE; +} + +ICALL_EXPORT MonoBoolean +ves_icall_System_RuntimeType_IsWindowsRuntimeObjectType (void) +{ + mono_set_pending_exception (mono_get_exception_not_implemented (NULL)); + return FALSE; +} + +ICALL_EXPORT void +ves_icall_MonoMethod_GetPInvoke (MonoReflectionMethod *method, int* flags, MonoString** entry_point, MonoString** dll_name) { - static MonoClass *DllImportAttributeClass = NULL; MonoDomain *domain = mono_domain_get (); - MonoReflectionDllImportAttribute *attr; - MonoImage *image = method->klass->image; - MonoMethodPInvoke *piinfo = (MonoMethodPInvoke *)method; + MonoImage *image = method->method->klass->image; + MonoMethodPInvoke *piinfo = (MonoMethodPInvoke *)method->method; MonoTableInfo *tables = image->tables; MonoTableInfo *im = &tables [MONO_TABLE_IMPLMAP]; MonoTableInfo *mr = &tables [MONO_TABLE_MODULEREF]; @@ -2601,30 +2541,18 @@ ves_icall_MonoMethod_GetDllImportAttribute (MonoMethod *method) guint32 scope_token; const char *import = NULL; const char *scope = NULL; - guint32 flags; - - if (!(method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL)) - return NULL; - if (!DllImportAttributeClass) { - DllImportAttributeClass = - mono_class_from_name (mono_defaults.corlib, - "System.Runtime.InteropServices", "DllImportAttribute"); - g_assert (DllImportAttributeClass); - } - - if (image_is_dynamic (method->klass->image)) { + if (image_is_dynamic (image)) { MonoReflectionMethodAux *method_aux = - g_hash_table_lookup ( - ((MonoDynamicImage*)method->klass->image)->method_aux_hash, method); + g_hash_table_lookup (((MonoDynamicImage*)image)->method_aux_hash, method->method); if (method_aux) { import = method_aux->dllentry; scope = method_aux->dll; } if (!import || !scope) { - mono_raise_exception (mono_get_exception_argument ("method", "System.Reflection.Emit method with invalid pinvoke information")); - return NULL; + mono_set_pending_exception (mono_get_exception_argument ("method", "System.Reflection.Emit method with invalid pinvoke information")); + return; } } else { @@ -2637,23 +2565,10 @@ ves_icall_MonoMethod_GetDllImportAttribute (MonoMethod *method) scope = mono_metadata_string_heap (image, scope_token); } } - flags = piinfo->piflags; - attr = (MonoReflectionDllImportAttribute*)mono_object_new (domain, DllImportAttributeClass); - - MONO_OBJECT_SETREF (attr, dll, mono_string_new (domain, scope)); - MONO_OBJECT_SETREF (attr, entry_point, mono_string_new (domain, import)); - attr->call_conv = (flags & 0x700) >> 8; - attr->charset = ((flags & 0x6) >> 1) + 1; - if (attr->charset == 1) - attr->charset = 2; - attr->exact_spelling = (flags & 0x1) != 0; - attr->set_last_error = (flags & 0x40) != 0; - attr->best_fit_mapping = (flags & 0x30) == 0x10; - attr->throw_on_unmappable = (flags & 0x3000) == 0x1000; - attr->preserve_sig = FALSE; - - return attr; + *flags = piinfo->piflags; + *entry_point = mono_string_new (domain, import); + *dll_name = mono_string_new (domain, scope); } ICALL_EXPORT MonoReflectionMethod * @@ -2662,8 +2577,6 @@ ves_icall_MonoMethod_GetGenericMethodDefinition (MonoReflectionMethod *method) MonoMethodInflated *imethod; MonoMethod *result; - MONO_ARCH_SAVE_REGS; - if (method->method->is_generic) return method; @@ -2696,8 +2609,11 @@ ves_icall_MonoMethod_GetGenericMethodDefinition (MonoReflectionMethod *method) if (imethod->context.class_inst) { MonoClass *klass = ((MonoMethod *) imethod)->klass; /*Generic methods gets the context of the GTD.*/ - if (mono_class_get_context (klass)) - result = mono_class_inflate_generic_method_full (result, klass, mono_class_get_context (klass)); + if (mono_class_get_context (klass)) { + MonoError error; + result = mono_class_inflate_generic_method_full_checked (result, klass, mono_class_get_context (klass), &error); + mono_error_raise_exception (&error); + } } return mono_method_get_object (mono_object_domain (method), result, NULL); @@ -2706,16 +2622,12 @@ ves_icall_MonoMethod_GetGenericMethodDefinition (MonoReflectionMethod *method) ICALL_EXPORT gboolean ves_icall_MonoMethod_get_IsGenericMethod (MonoReflectionMethod *method) { - MONO_ARCH_SAVE_REGS; - return mono_method_signature (method->method)->generic_param_count != 0; } ICALL_EXPORT gboolean ves_icall_MonoMethod_get_IsGenericMethodDefinition (MonoReflectionMethod *method) { - MONO_ARCH_SAVE_REGS; - return method->method->is_generic; } @@ -2725,7 +2637,6 @@ ves_icall_MonoMethod_GetGenericArguments (MonoReflectionMethod *method) MonoArray *res; MonoDomain *domain; int count, i; - MONO_ARCH_SAVE_REGS; domain = mono_object_domain (method); @@ -2759,7 +2670,7 @@ ves_icall_MonoMethod_GetGenericArguments (MonoReflectionMethod *method) } ICALL_EXPORT MonoObject * -ves_icall_InternalInvoke (MonoReflectionMethod *method, MonoObject *this, MonoArray *params, MonoException **exc) +ves_icall_InternalInvoke (MonoReflectionMethod *method, MonoObject *this_arg, MonoArray *params, MonoException **exc) { /* * Invoke from reflection is supposed to always be a virtual call (the API @@ -2770,9 +2681,7 @@ ves_icall_InternalInvoke (MonoReflectionMethod *method, MonoObject *this, MonoAr MonoMethodSignature *sig = mono_method_signature (m); MonoImage *image; int pcount; - void *obj = this; - - MONO_ARCH_SAVE_REGS; + void *obj = this_arg; *exc = NULL; @@ -2785,9 +2694,9 @@ ves_icall_InternalInvoke (MonoReflectionMethod *method, MonoObject *this, MonoAr return NULL; } - if (this) { - if (!mono_object_isinst (this, m->klass)) { - char *this_name = mono_type_get_full_name (mono_object_get_class (this)); + if (this_arg) { + if (!mono_object_isinst (this_arg, m->klass)) { + char *this_name = mono_type_get_full_name (mono_object_get_class (this_arg)); char *target_name = mono_type_get_full_name (m->klass); char *msg = g_strdup_printf ("Object of type '%s' doesn't match target type '%s'", this_name, target_name); mono_gc_wbarrier_generic_store (exc, (MonoObject*) mono_exception_from_name_msg (mono_defaults.corlib, "System.Reflection", "TargetException", msg)); @@ -2796,10 +2705,10 @@ ves_icall_InternalInvoke (MonoReflectionMethod *method, MonoObject *this, MonoAr g_free (this_name); return NULL; } - m = mono_object_get_virtual_method (this, m); + m = mono_object_get_virtual_method (this_arg, m); /* must pass the pointer to the value for valuetype methods */ if (m->klass->valuetype) - obj = mono_object_unbox (this); + obj = mono_object_unbox (this_arg); } else if (strcmp (m->name, ".ctor") && !m->wrapper_type) { mono_gc_wbarrier_generic_store (exc, (MonoObject*) mono_exception_from_name_msg (mono_defaults.corlib, "System.Reflection", "TargetException", "Non-static method requires a target.")); return NULL; @@ -2817,7 +2726,7 @@ ves_icall_InternalInvoke (MonoReflectionMethod *method, MonoObject *this, MonoAr return NULL; } - if ((m->klass->flags & TYPE_ATTRIBUTE_ABSTRACT) && !strcmp (m->name, ".ctor") && !this) { + if ((m->klass->flags & TYPE_ATTRIBUTE_ABSTRACT) && !strcmp (m->name, ".ctor") && !this_arg) { mono_gc_wbarrier_generic_store (exc, (MonoObject*) mono_exception_from_name_msg (mono_defaults.corlib, "System.Reflection", "TargetException", "Cannot invoke constructor of an abstract class.")); return NULL; } @@ -2857,22 +2766,26 @@ ves_icall_InternalInvoke (MonoReflectionMethod *method, MonoObject *this, MonoAr if (m->klass->rank == pcount) { /* Only lengths provided. */ - lower_bounds = NULL; + return (MonoObject*)mono_array_new_full (mono_object_domain (params), m->klass, lengths, NULL); } else { g_assert (pcount == (m->klass->rank * 2)); - /* lower bounds are first. */ - lower_bounds = (intptr_t*)lengths; - lengths += m->klass->rank; - } + /* The arguments are lower-bound-length pairs */ + lower_bounds = g_alloca (sizeof (intptr_t) * pcount); + + for (i = 0; i < pcount / 2; ++i) { + lower_bounds [i] = *(int32_t*) ((char*)mono_array_get (params, gpointer, (i * 2)) + sizeof (MonoObject)); + lengths [i] = *(int32_t*) ((char*)mono_array_get (params, gpointer, (i * 2) + 1) + sizeof (MonoObject)); + } - return (MonoObject*)mono_array_new_full (mono_object_domain (params), m->klass, lengths, lower_bounds); + return (MonoObject*)mono_array_new_full (mono_object_domain (params), m->klass, lengths, lower_bounds); + } } return mono_runtime_invoke_array (m, obj, params, NULL); } #ifndef DISABLE_REMOTING ICALL_EXPORT MonoObject * -ves_icall_InternalExecute (MonoReflectionMethod *method, MonoObject *this, MonoArray *params, MonoArray **outArgs) +ves_icall_InternalExecute (MonoReflectionMethod *method, MonoObject *this_arg, MonoArray *params, MonoArray **outArgs) { MonoDomain *domain = mono_object_domain (method); MonoMethod *m = method->method; @@ -2881,21 +2794,18 @@ ves_icall_InternalExecute (MonoReflectionMethod *method, MonoObject *this, MonoA MonoObject *result; int i, j, outarg_count = 0; - MONO_ARCH_SAVE_REGS; - if (m->klass == mono_defaults.object_class) { - if (!strcmp (m->name, "FieldGetter")) { - MonoClass *k = this->vtable->klass; + MonoClass *k = this_arg->vtable->klass; MonoString *name; char *str; /* If this is a proxy, then it must be a CBO */ if (k == mono_defaults.transparent_proxy_class) { - MonoTransparentProxy *tp = (MonoTransparentProxy*) this; - this = tp->rp->unwrapped_server; - g_assert (this); - k = this->vtable->klass; + MonoTransparentProxy *tp = (MonoTransparentProxy*) this_arg; + this_arg = tp->rp->unwrapped_server; + g_assert (this_arg); + k = this_arg->vtable->klass; } name = mono_array_get (params, MonoString *, 1); @@ -2906,9 +2816,9 @@ ves_icall_InternalExecute (MonoReflectionMethod *method, MonoObject *this, MonoA if (field) { MonoClass *field_klass = mono_class_from_mono_type (field->type); if (field_klass->valuetype) - result = mono_value_box (domain, field_klass, (char *)this + field->offset); + result = mono_value_box (domain, field_klass, (char *)this_arg + field->offset); else - result = *((gpointer *)((char *)this + field->offset)); + result = *((gpointer *)((char *)this_arg + field->offset)); out_args = mono_array_new (domain, mono_defaults.object_class, 1); mono_gc_wbarrier_generic_store (outArgs, (MonoObject*) out_args); @@ -2923,7 +2833,7 @@ ves_icall_InternalExecute (MonoReflectionMethod *method, MonoObject *this, MonoA g_assert_not_reached (); } else if (!strcmp (m->name, "FieldSetter")) { - MonoClass *k = this->vtable->klass; + MonoClass *k = this_arg->vtable->klass; MonoString *name; guint32 size; gint32 align; @@ -2931,10 +2841,10 @@ ves_icall_InternalExecute (MonoReflectionMethod *method, MonoObject *this, MonoA /* If this is a proxy, then it must be a CBO */ if (k == mono_defaults.transparent_proxy_class) { - MonoTransparentProxy *tp = (MonoTransparentProxy*) this; - this = tp->rp->unwrapped_server; - g_assert (this); - k = this->vtable->klass; + MonoTransparentProxy *tp = (MonoTransparentProxy*) this_arg; + this_arg = tp->rp->unwrapped_server; + g_assert (this_arg); + k = this_arg->vtable->klass; } name = mono_array_get (params, MonoString *, 1); @@ -2949,9 +2859,9 @@ ves_icall_InternalExecute (MonoReflectionMethod *method, MonoObject *this, MonoA if (field_klass->valuetype) { size = mono_type_size (field->type, &align); g_assert (size == mono_class_value_size (field_klass, NULL)); - mono_gc_wbarrier_value_copy ((char *)this + field->offset, (char*)val + sizeof (MonoObject), 1, field_klass); + mono_gc_wbarrier_value_copy ((char *)this_arg + field->offset, (char*)val + sizeof (MonoObject), 1, field_klass); } else { - mono_gc_wbarrier_set_field (this, (char*)this + field->offset, val); + mono_gc_wbarrier_set_field (this_arg, (char*)this_arg + field->offset, val); } out_args = mono_array_new (domain, mono_defaults.object_class, 0); @@ -2979,11 +2889,11 @@ ves_icall_InternalExecute (MonoReflectionMethod *method, MonoObject *this, MonoA /* handle constructors only for objects already allocated */ if (!strcmp (method->method->name, ".ctor")) - g_assert (this); + g_assert (this_arg); /* This can be called only on MBR objects, so no need to unbox for valuetypes. */ g_assert (!method->method->klass->valuetype); - result = mono_runtime_invoke_array (method->method, this, params, NULL); + result = mono_runtime_invoke_array (method->method, this_arg, params, NULL); for (i = 0, j = 0; i < mono_array_length (params); i++) { if (sig->params [i]->byref) { @@ -3001,25 +2911,26 @@ ves_icall_InternalExecute (MonoReflectionMethod *method, MonoObject *this, MonoA #endif static guint64 -read_enum_value (char *mem, int type) +read_enum_value (const char *mem, int type) { switch (type) { + case MONO_TYPE_BOOLEAN: case MONO_TYPE_U1: return *(guint8*)mem; case MONO_TYPE_I1: return *(gint8*)mem; + case MONO_TYPE_CHAR: case MONO_TYPE_U2: - return *(guint16*)mem; + return read16 (mem); case MONO_TYPE_I2: - return *(gint16*)mem; + return (gint16) read16 (mem); case MONO_TYPE_U4: - return *(guint32*)mem; + return read32 (mem); case MONO_TYPE_I4: - return *(gint32*)mem; + return (gint32) read32 (mem); case MONO_TYPE_U8: - return *(guint64*)mem; case MONO_TYPE_I8: - return *(gint64*)mem; + return read64 (mem); default: g_assert_not_reached (); } @@ -3061,45 +2972,40 @@ write_enum_value (char *mem, int type, guint64 value) } ICALL_EXPORT MonoObject * -ves_icall_System_Enum_ToObject (MonoReflectionType *enumType, MonoObject *value) +ves_icall_System_Enum_ToObject (MonoReflectionType *enumType, guint64 value) { MonoDomain *domain; - MonoClass *enumc, *objc; + MonoClass *enumc; MonoObject *res; MonoType *etype; - guint64 val; - - MONO_ARCH_SAVE_REGS; - - MONO_CHECK_ARG_NULL (enumType); - MONO_CHECK_ARG_NULL (value); domain = mono_object_domain (enumType); enumc = mono_class_from_mono_type (enumType->type); mono_class_init_or_throw (enumc); - objc = value->vtable->klass; - - if (!enumc->enumtype) - mono_raise_exception (mono_get_exception_argument ("enumType", "Type provided must be an Enum.")); - if (!((objc->enumtype) || (objc->byval_arg.type >= MONO_TYPE_I1 && objc->byval_arg.type <= MONO_TYPE_U8))) - mono_raise_exception (mono_get_exception_argument ("value", "The value passed in must be an enum base or an underlying type for an enum, such as an Int32.")); - etype = mono_class_enum_basetype (enumc); - if (!etype) - /* MS throws this for typebuilders */ - mono_raise_exception (mono_get_exception_argument ("Type must be a type provided by the runtime.", "enumType")); res = mono_object_new (domain, enumc); - val = read_enum_value ((char *)value + sizeof (MonoObject), objc->enumtype? mono_class_enum_basetype (objc)->type: objc->byval_arg.type); - write_enum_value ((char *)res + sizeof (MonoObject), etype->type, val); + write_enum_value ((char *)res + sizeof (MonoObject), etype->type, value); return res; } +ICALL_EXPORT MonoBoolean +ves_icall_System_Enum_InternalHasFlag (MonoObject *a, MonoObject *b) +{ + int size = mono_class_value_size (a->vtable->klass, NULL); + guint64 a_val = 0, b_val = 0; + + memcpy (&a_val, mono_object_unbox (a), size); + memcpy (&b_val, mono_object_unbox (b), size); + + return (a_val & b_val) == b_val; +} + ICALL_EXPORT MonoObject * -ves_icall_System_Enum_get_value (MonoObject *this) +ves_icall_System_Enum_get_value (MonoObject *eobj) { MonoObject *res; MonoClass *enumc; @@ -3107,17 +3013,15 @@ ves_icall_System_Enum_get_value (MonoObject *this) gpointer src; int size; - MONO_ARCH_SAVE_REGS; - - if (!this) + if (!eobj) return NULL; - g_assert (this->vtable->klass->enumtype); + g_assert (eobj->vtable->klass->enumtype); - enumc = mono_class_from_mono_type (mono_class_enum_basetype (this->vtable->klass)); - res = mono_object_new (mono_object_domain (this), enumc); + enumc = mono_class_from_mono_type (mono_class_enum_basetype (eobj->vtable->klass)); + res = mono_object_new (mono_object_domain (eobj), enumc); dst = (char *)res + sizeof (MonoObject); - src = (char *)this + sizeof (MonoObject); + src = (char *)eobj + sizeof (MonoObject); size = mono_class_value_size (enumc, NULL); memcpy (dst, src, size); @@ -3131,27 +3035,32 @@ ves_icall_System_Enum_get_underlying_type (MonoReflectionType *type) MonoType *etype; MonoClass *klass; - MONO_ARCH_SAVE_REGS; - klass = mono_class_from_mono_type (type->type); mono_class_init_or_throw (klass); etype = mono_class_enum_basetype (klass); - if (!etype) - /* MS throws this for typebuilders */ - mono_raise_exception (mono_get_exception_argument ("Type must be a type provided by the runtime.", "enumType")); + if (!etype) { + mono_set_pending_exception (mono_get_exception_argument ("enumType", "Type provided must be an Enum.")); + return NULL; + } return mono_type_get_object (mono_object_domain (type), etype); } ICALL_EXPORT int -ves_icall_System_Enum_compare_value_to (MonoObject *this, MonoObject *other) +ves_icall_System_Enum_compare_value_to (MonoObject *eobj, MonoObject *other) { - gpointer tdata = (char *)this + sizeof (MonoObject); + gpointer tdata = (char *)eobj + sizeof (MonoObject); gpointer odata = (char *)other + sizeof (MonoObject); - MonoType *basetype = mono_class_enum_basetype (this->vtable->klass); + MonoType *basetype = mono_class_enum_basetype (eobj->vtable->klass); g_assert (basetype); + if (other == NULL) + return 1; + + if (eobj->vtable->klass != other->vtable->klass) + return 2; + #define COMPARE_ENUM_VALUES(ENUM_TYPE) do { \ ENUM_TYPE me = *((ENUM_TYPE*)tdata); \ ENUM_TYPE other = *((ENUM_TYPE*)odata); \ @@ -3179,17 +3088,18 @@ ves_icall_System_Enum_compare_value_to (MonoObject *this, MonoObject *other) case MONO_TYPE_I8: COMPARE_ENUM_VALUES (gint64); default: - g_error ("Implement type 0x%02x in get_hashcode", basetype->type); + break; } #undef COMPARE_ENUM_VALUES - return 0; + /* indicates that the enum was of an unsupported unerlying type */ + return 3; } ICALL_EXPORT int -ves_icall_System_Enum_get_hashcode (MonoObject *this) +ves_icall_System_Enum_get_hashcode (MonoObject *eobj) { - gpointer data = (char *)this + sizeof (MonoObject); - MonoType *basetype = mono_class_enum_basetype (this->vtable->klass); + gpointer data = (char *)eobj + sizeof (MonoObject); + MonoType *basetype = mono_class_enum_basetype (eobj->vtable->klass); g_assert (basetype); switch (basetype->type) { @@ -3218,64 +3128,58 @@ ves_icall_System_Enum_get_hashcode (MonoObject *this) return 0; } -ICALL_EXPORT void -ves_icall_get_enum_info (MonoReflectionType *type, MonoEnumInfo *info) +ICALL_EXPORT MonoBoolean +ves_icall_System_Enum_GetEnumValuesAndNames (MonoReflectionType *type, MonoArray **values, MonoArray **names) { MonoDomain *domain = mono_object_domain (type); MonoClass *enumc = mono_class_from_mono_type (type->type); - guint j = 0, nvalues, crow; + guint j = 0, nvalues; gpointer iter; MonoClassField *field; - - MONO_ARCH_SAVE_REGS; + int base_type; + guint64 field_value, previous_value = 0; + gboolean sorted = TRUE; mono_class_init_or_throw (enumc); - MONO_STRUCT_SETREF (info, utype, mono_type_get_object (domain, mono_class_enum_basetype (enumc))); + if (!enumc->enumtype) { + mono_set_pending_exception (mono_get_exception_argument ("enumType", "Type provided must be an Enum.")); + return TRUE; + } + + base_type = mono_class_enum_basetype (enumc)->type; + nvalues = mono_class_num_fields (enumc) ? mono_class_num_fields (enumc) - 1 : 0; - MONO_STRUCT_SETREF (info, names, mono_array_new (domain, mono_defaults.string_class, nvalues)); - MONO_STRUCT_SETREF (info, values, mono_array_new (domain, enumc, nvalues)); + *names = mono_array_new (domain, mono_defaults.string_class, nvalues); + *values = mono_array_new (domain, mono_defaults.uint64_class, nvalues); - crow = -1; iter = NULL; while ((field = mono_class_get_fields (enumc, &iter))) { const char *p; - int len; MonoTypeEnum def_type; - + if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC)) continue; if (strcmp ("value__", mono_field_get_name (field)) == 0) continue; if (mono_field_is_deleted (field)) continue; - mono_array_setref (info->names, j, mono_string_new (domain, mono_field_get_name (field))); + mono_array_setref (*names, j, mono_string_new (domain, mono_field_get_name (field))); p = mono_class_get_field_default_value (field, &def_type); - len = mono_metadata_decode_blob_size (p, &p); - switch (mono_class_enum_basetype (enumc)->type) { - case MONO_TYPE_U1: - case MONO_TYPE_I1: - mono_array_set (info->values, gchar, j, *p); - break; - case MONO_TYPE_CHAR: - case MONO_TYPE_U2: - case MONO_TYPE_I2: - mono_array_set (info->values, gint16, j, read16 (p)); - break; - case MONO_TYPE_U4: - case MONO_TYPE_I4: - mono_array_set (info->values, gint32, j, read32 (p)); - break; - case MONO_TYPE_U8: - case MONO_TYPE_I8: - mono_array_set (info->values, gint64, j, read64 (p)); - break; - default: - g_error ("Implement type 0x%02x in get_enum_info", mono_class_enum_basetype (enumc)->type); - } + /* len = */ mono_metadata_decode_blob_size (p, &p); + + field_value = read_enum_value (p, base_type); + mono_array_set (*values, guint64, j, field_value); + + if (previous_value > field_value) + sorted = FALSE; + + previous_value = field_value; ++j; } + + return sorted; } enum { @@ -3297,78 +3201,8 @@ enum { BFLAGS_OptionalParamBinding = 0x40000 }; -ICALL_EXPORT MonoReflectionField * -ves_icall_Type_GetField (MonoReflectionType *type, MonoString *name, guint32 bflags) -{ - MonoDomain *domain; - MonoClass *startklass, *klass; - int match; - MonoClassField *field; - gpointer iter; - char *utf8_name; - int (*compare_func) (const char *s1, const char *s2) = NULL; - domain = ((MonoObject *)type)->vtable->domain; - klass = startklass = mono_class_from_mono_type (type->type); - - if (!name) - mono_raise_exception (mono_get_exception_argument_null ("name")); - if (type->type->byref) - return NULL; - - compare_func = (bflags & BFLAGS_IgnoreCase) ? mono_utf8_strcasecmp : strcmp; - -handle_parent: - if (klass->exception_type != MONO_EXCEPTION_NONE) - mono_raise_exception (mono_class_get_exception_for_failure (klass)); - - iter = NULL; - while ((field = mono_class_get_fields_lazy (klass, &iter))) { - guint32 flags = mono_field_get_flags (field); - match = 0; - - if (mono_field_is_deleted_with_flags (field, flags)) - continue; - if ((flags & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK) == FIELD_ATTRIBUTE_PUBLIC) { - if (bflags & BFLAGS_Public) - match++; - } else if ((klass == startklass) || (flags & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK) != FIELD_ATTRIBUTE_PRIVATE) { - if (bflags & BFLAGS_NonPublic) { - match++; - } - } - if (!match) - continue; - match = 0; - if (flags & FIELD_ATTRIBUTE_STATIC) { - if (bflags & BFLAGS_Static) - if ((bflags & BFLAGS_FlattenHierarchy) || (klass == startklass)) - match++; - } else { - if (bflags & BFLAGS_Instance) - match++; - } - - if (!match) - continue; - - utf8_name = mono_string_to_utf8 (name); - - if (compare_func (mono_field_get_name (field), utf8_name)) { - g_free (utf8_name); - continue; - } - g_free (utf8_name); - - return mono_field_get_object (domain, klass, field); - } - if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent)) - goto handle_parent; - - return NULL; -} - ICALL_EXPORT MonoArray* -ves_icall_Type_GetFields_internal (MonoReflectionType *type, guint32 bflags, MonoReflectionType *reftype) +ves_icall_Type_GetFields_internal (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoReflectionType *reftype) { MonoDomain *domain; MonoClass *startklass, *klass, *refklass; @@ -3376,23 +3210,25 @@ ves_icall_Type_GetFields_internal (MonoReflectionType *type, guint32 bflags, Mon MonoObject *member; int i, match; gpointer iter; + char *utf8_name = NULL; + int (*compare_func) (const char *s1, const char *s2) = NULL; MonoClassField *field; MonoPtrArray tmp_array; - MONO_ARCH_SAVE_REGS; - domain = ((MonoObject *)type)->vtable->domain; if (type->type->byref) return mono_array_new (domain, mono_defaults.field_info_class, 0); + klass = startklass = mono_class_from_mono_type (type->type); refklass = mono_class_from_mono_type (reftype->type); - mono_ptr_array_init (tmp_array, 2); + mono_ptr_array_init (tmp_array, 2, MONO_ROOT_SOURCE_REFLECTION, "temporary reflection fields list"); handle_parent: if (klass->exception_type != MONO_EXCEPTION_NONE) { mono_ptr_array_destroy (tmp_array); - mono_raise_exception (mono_class_get_exception_for_failure (klass)); + mono_set_pending_exception (mono_class_get_exception_for_failure (klass)); + return NULL; } iter = NULL; @@ -3423,6 +3259,17 @@ handle_parent: if (!match) continue; + + if (name != NULL) { + if (utf8_name == NULL) { + utf8_name = mono_string_to_utf8 (name); + compare_func = (bflags & BFLAGS_IgnoreCase) ? mono_utf8_strcasecmp : strcmp; + } + + if (compare_func (mono_field_get_name (field), utf8_name)) + continue; + } + member = (MonoObject*)mono_field_get_object (domain, refklass, field); mono_ptr_array_append (tmp_array, member); } @@ -3436,6 +3283,9 @@ handle_parent: mono_ptr_array_destroy (tmp_array); + if (utf8_name != NULL) + g_free (utf8_name); + return res; } @@ -3461,7 +3311,7 @@ mono_class_get_methods_by_name (MonoClass *klass, const char *name, guint32 bfla MonoClass *startklass; MonoMethod *method; gpointer iter; - int len, match, nslots; + int match, nslots; /*FIXME, use MonoBitSet*/ guint32 method_slots_default [8]; guint32 *method_slots = NULL; @@ -3471,7 +3321,6 @@ mono_class_get_methods_by_name (MonoClass *klass, const char *name, guint32 bfla startklass = klass; *ex = NULL; - len = 0; if (name != NULL) compare_func = (ignore_case) ? mono_utf8_strcasecmp : strcmp; @@ -3485,6 +3334,7 @@ mono_class_get_methods_by_name (MonoClass *klass, const char *name, guint32 bfla return array; } + mono_class_setup_methods (klass); mono_class_setup_vtable (klass); if (klass->exception_type != MONO_EXCEPTION_NONE || mono_loader_get_last_error ()) goto loader_error; @@ -3500,6 +3350,7 @@ mono_class_get_methods_by_name (MonoClass *klass, const char *name, guint32 bfla memset (method_slots, 0, sizeof (method_slots_default)); } handle_parent: + mono_class_setup_methods (klass); mono_class_setup_vtable (klass); if (klass->exception_type != MONO_EXCEPTION_NONE || mono_loader_get_last_error ()) goto loader_error; @@ -3598,12 +3449,13 @@ ves_icall_Type_GetMethodsByName (MonoReflectionType *type, MonoString *name, gui method_array = mono_class_get_methods_by_name (klass, mname, bflags, ignore_case, FALSE, &ex); g_free ((char*)mname); - if (ex) - mono_raise_exception (ex); + if (ex) { + mono_set_pending_exception (ex); + return NULL; + } res = mono_array_new_specific (array_vtable, method_array->len); - for (i = 0; i < method_array->len; ++i) { MonoMethod *method = g_ptr_array_index (method_array, i); mono_array_setref (res, i, mono_method_get_object (domain, method, refklass)); @@ -3626,9 +3478,7 @@ ves_icall_Type_GetConstructors_internal (MonoReflectionType *type, guint32 bflag gpointer iter = NULL; MonoPtrArray tmp_array; - MONO_ARCH_SAVE_REGS; - - mono_ptr_array_init (tmp_array, 4); /*FIXME, guestimating*/ + mono_ptr_array_init (tmp_array, 4, MONO_ROOT_SOURCE_REFLECTION, "temporary reflection constructors list"); /*FIXME, guestimating*/ domain = ((MonoObject *)type)->vtable->domain; if (type->type->byref) @@ -3640,6 +3490,12 @@ ves_icall_Type_GetConstructors_internal (MonoReflectionType *type, guint32 bflag System_Reflection_ConstructorInfo = mono_class_from_name ( mono_defaults.corlib, "System.Reflection", "ConstructorInfo"); + mono_class_setup_methods (klass); + if (klass->exception_type != MONO_EXCEPTION_NONE) { + mono_set_pending_exception (mono_class_get_exception_for_failure (klass)); + return NULL; + } + iter = NULL; while ((method = mono_class_get_methods (klass, &iter))) { match = 0; @@ -3730,9 +3586,7 @@ ves_icall_Type_GetPropertiesByName (MonoReflectionType *type, MonoString *name, GHashTable *properties = NULL; MonoPtrArray tmp_array; - MONO_ARCH_SAVE_REGS; - - mono_ptr_array_init (tmp_array, 8); /*This the average for ASP.NET types*/ + mono_ptr_array_init (tmp_array, 8, MONO_ROOT_SOURCE_REFLECTION, "temporary reflection properties list"); /*This the average for ASP.NET types*/ if (!System_Reflection_PropertyInfo) System_Reflection_PropertyInfo = mono_class_from_name ( @@ -3750,6 +3604,7 @@ ves_icall_Type_GetPropertiesByName (MonoReflectionType *type, MonoString *name, properties = g_hash_table_new (property_hash, (GEqualFunc)property_equal); handle_parent: + mono_class_setup_methods (klass); mono_class_setup_vtable (klass); if (klass->exception_type != MONO_EXCEPTION_NONE || mono_loader_get_last_error ()) goto loader_error; @@ -3829,78 +3684,7 @@ loader_error: ex = mono_loader_error_prepare_exception (mono_loader_get_last_error ()); mono_loader_clear_error (); } - mono_raise_exception (ex); - return NULL; -} - -ICALL_EXPORT MonoReflectionEvent * -ves_icall_MonoType_GetEvent (MonoReflectionType *type, MonoString *name, guint32 bflags) -{ - MonoDomain *domain; - MonoClass *klass, *startklass; - gpointer iter; - MonoEvent *event; - MonoMethod *method; - gchar *event_name; - int (*compare_func) (const char *s1, const char *s2); - - MONO_ARCH_SAVE_REGS; - - event_name = mono_string_to_utf8 (name); - if (type->type->byref) - return NULL; - klass = startklass = mono_class_from_mono_type (type->type); - domain = mono_object_domain (type); - - mono_class_init_or_throw (klass); - - compare_func = (bflags & BFLAGS_IgnoreCase) ? mono_utf8_strcasecmp : strcmp; -handle_parent: - if (klass->exception_type != MONO_EXCEPTION_NONE) - mono_raise_exception (mono_class_get_exception_for_failure (klass)); - - iter = NULL; - while ((event = mono_class_get_events (klass, &iter))) { - if (compare_func (event->name, event_name)) - continue; - - method = event->add; - if (!method) - method = event->remove; - if (!method) - method = event->raise; - if (method) { - if ((method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC) { - if (!(bflags & BFLAGS_Public)) - continue; - } else { - if (!(bflags & BFLAGS_NonPublic)) - continue; - if ((klass != startklass) && (method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PRIVATE) - continue; - } - - if (method->flags & METHOD_ATTRIBUTE_STATIC) { - if (!(bflags & BFLAGS_Static)) - continue; - if (!(bflags & BFLAGS_FlattenHierarchy) && (klass != startklass)) - continue; - } else { - if (!(bflags & BFLAGS_Instance)) - continue; - } - } else - if (!(bflags & BFLAGS_NonPublic)) - continue; - - g_free (event_name); - return mono_event_get_object (domain, startklass, event); - } - - if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent)) - goto handle_parent; - - g_free (event_name); + mono_set_pending_exception (ex); return NULL; } @@ -3920,7 +3704,7 @@ event_equal (MonoEvent *event1, MonoEvent *event2) } ICALL_EXPORT MonoArray* -ves_icall_Type_GetEvents_internal (MonoReflectionType *type, guint32 bflags, MonoReflectionType *reftype) +ves_icall_Type_GetEvents_internal (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoReflectionType *reftype) { MonoException *ex; MonoDomain *domain; @@ -3931,12 +3715,12 @@ ves_icall_Type_GetEvents_internal (MonoReflectionType *type, guint32 bflags, Mon MonoEvent *event; int i, match; gpointer iter; + char *utf8_name = NULL; + int (*compare_func) (const char *s1, const char *s2) = NULL; GHashTable *events = NULL; MonoPtrArray tmp_array; - MONO_ARCH_SAVE_REGS; - - mono_ptr_array_init (tmp_array, 4); + mono_ptr_array_init (tmp_array, 4, MONO_ROOT_SOURCE_REFLECTION, "temporary reflection events list"); if (!System_Reflection_EventInfo) System_Reflection_EventInfo = mono_class_from_name ( @@ -3949,6 +3733,7 @@ ves_icall_Type_GetEvents_internal (MonoReflectionType *type, guint32 bflags, Mon events = g_hash_table_new (event_hash, (GEqualFunc)event_equal); handle_parent: + mono_class_setup_methods (klass); mono_class_setup_vtable (klass); if (klass->exception_type != MONO_EXCEPTION_NONE || mono_loader_get_last_error ()) goto loader_error; @@ -3992,6 +3777,16 @@ handle_parent: if (!match) continue; + if (name != NULL) { + if (utf8_name == NULL) { + utf8_name = mono_string_to_utf8 (name); + compare_func = (bflags & BFLAGS_IgnoreCase) ? mono_utf8_strcasecmp : strcmp; + } + + if (compare_func (event->name, utf8_name)) + continue; + } + if (g_hash_table_lookup (events, event)) continue; @@ -4011,6 +3806,9 @@ handle_parent: mono_ptr_array_destroy (tmp_array); + if (utf8_name != NULL) + g_free (utf8_name); + return res; loader_error: @@ -4021,72 +3819,12 @@ loader_error: ex = mono_loader_error_prepare_exception (mono_loader_get_last_error ()); mono_loader_clear_error (); } - mono_raise_exception (ex); - return NULL; -} - -ICALL_EXPORT MonoReflectionType * -ves_icall_Type_GetNestedType (MonoReflectionType *type, MonoString *name, guint32 bflags) -{ - MonoDomain *domain; - MonoClass *klass; - MonoClass *nested; - char *str; - gpointer iter; - - MONO_ARCH_SAVE_REGS; - - if (name == NULL) - mono_raise_exception (mono_get_exception_argument_null ("name")); - - domain = ((MonoObject *)type)->vtable->domain; - if (type->type->byref) - return NULL; - klass = mono_class_from_mono_type (type->type); - - str = mono_string_to_utf8 (name); - - handle_parent: - if (klass->exception_type != MONO_EXCEPTION_NONE) - mono_raise_exception (mono_class_get_exception_for_failure (klass)); - - /* - * If a nested type is generic, return its generic type definition. - * Note that this means that the return value is essentially a - * nested type of the generic type definition of @klass. - * - * A note in MSDN claims that a generic type definition can have - * nested types that aren't generic. In any case, the container of that - * nested type would be the generic type definition. - */ - if (klass->generic_class) - klass = klass->generic_class->container_class; - - iter = NULL; - while ((nested = mono_class_get_nested_types (klass, &iter))) { - int match = 0; - if ((nested->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK) == TYPE_ATTRIBUTE_NESTED_PUBLIC) { - if (bflags & BFLAGS_Public) - match++; - } else { - if (bflags & BFLAGS_NonPublic) - match++; - } - if (!match) - continue; - if (strcmp (nested->name, str) == 0){ - g_free (str); - return mono_type_get_object (domain, &nested->byval_arg); - } - } - if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent)) - goto handle_parent; - g_free (str); + mono_set_pending_exception (ex); return NULL; } ICALL_EXPORT MonoArray* -ves_icall_Type_GetNestedTypes (MonoReflectionType *type, guint32 bflags) +ves_icall_Type_GetNestedTypes (MonoReflectionType *type, MonoString *name, guint32 bflags) { MonoDomain *domain; MonoClass *klass; @@ -4095,10 +3833,9 @@ ves_icall_Type_GetNestedTypes (MonoReflectionType *type, guint32 bflags) int i, match; MonoClass *nested; gpointer iter; + char *str = NULL; MonoPtrArray tmp_array; - MONO_ARCH_SAVE_REGS; - domain = ((MonoObject *)type)->vtable->domain; if (type->type->byref) return mono_array_new (domain, mono_defaults.monotype_class, 0); @@ -4116,7 +3853,7 @@ ves_icall_Type_GetNestedTypes (MonoReflectionType *type, guint32 bflags) if (klass->generic_class) klass = klass->generic_class->container_class; - mono_ptr_array_init (tmp_array, 1); + mono_ptr_array_init (tmp_array, 1, MONO_ROOT_SOURCE_REFLECTION, "temporary reflection nested types list"); iter = NULL; while ((nested = mono_class_get_nested_types (klass, &iter))) { match = 0; @@ -4129,6 +3866,15 @@ ves_icall_Type_GetNestedTypes (MonoReflectionType *type, guint32 bflags) } if (!match) continue; + + if (name != NULL) { + if (str == NULL) + str = mono_string_to_utf8 (name); + + if (strcmp (nested->name, str)) + continue; + } + member = (MonoObject*)mono_type_get_object (domain, &nested->byval_arg); mono_ptr_array_append (tmp_array, member); } @@ -4140,6 +3886,9 @@ ves_icall_Type_GetNestedTypes (MonoReflectionType *type, guint32 bflags) mono_ptr_array_destroy (tmp_array); + if (!str) + g_free (str); + return res; } @@ -4151,8 +3900,6 @@ ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssembly *as MonoTypeNameParse info; gboolean type_resolve; - MONO_ARCH_SAVE_REGS; - /* On MS.NET, this does not fire a TypeResolve event */ type_resolve = TRUE; str = mono_string_to_utf8 (name); @@ -4160,8 +3907,11 @@ ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssembly *as if (!mono_reflection_parse_type (str, &info)) { g_free (str); mono_reflection_free_type_info (&info); - if (throwOnError) /* uhm: this is a parse error, though... */ - mono_raise_exception (mono_get_exception_type_load (name, NULL)); + if (throwOnError) { + /* uhm: this is a parse error, though... */ + mono_set_pending_exception (mono_get_exception_type_load (name, NULL)); + return NULL; + } /*g_print ("failed parse\n");*/ return NULL; } @@ -4172,9 +3922,10 @@ ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssembly *as if (throwOnError) { /* 1.0 and 2.0 throw different exceptions */ if (mono_defaults.generic_ilist_class) - mono_raise_exception (mono_get_exception_argument (NULL, "Type names passed to Assembly.GetType() must not specify an assembly.")); + mono_set_pending_exception (mono_get_exception_argument (NULL, "Type names passed to Assembly.GetType() must not specify an assembly.")); else - mono_raise_exception (mono_get_exception_type_load (name, NULL)); + mono_set_pending_exception (mono_get_exception_type_load (name, NULL)); + return NULL; } return NULL; } @@ -4226,29 +3977,25 @@ ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssembly *as mono_loader_clear_error (); if (e != NULL) - mono_raise_exception (e); - + mono_set_pending_exception (e); return NULL; } else if (mono_loader_get_last_error ()) { - if (throwOnError) - mono_raise_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ())); + if (throwOnError) { + mono_set_pending_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ())); + return NULL; + } mono_loader_clear_error (); } if (type->type == MONO_TYPE_CLASS) { MonoClass *klass = mono_type_get_class (type); - if (mono_security_enabled () && !klass->exception_type) - /* Some security problems are detected during generic vtable construction */ - mono_class_setup_vtable (klass); - /* need to report exceptions ? */ if (throwOnError && klass->exception_type) { /* report SecurityException (or others) that occured when loading the assembly */ MonoException *exc = mono_class_get_exception_for_failure (klass); mono_loader_clear_error (); - mono_raise_exception (exc); - } else if (mono_security_enabled () && klass->exception_type == MONO_EXCEPTION_SECURITY_INHERITANCEDEMAND) { + mono_set_pending_exception (exc); return NULL; } } @@ -4296,8 +4043,6 @@ ves_icall_System_Reflection_Assembly_get_code_base (MonoReflectionAssembly *asse gchar *absolute; gchar *dirname; - MONO_ARCH_SAVE_REGS; - if (g_path_is_absolute (mass->image->name)) { absolute = g_strdup (mass->image->name); dirname = g_path_get_dirname (absolute); @@ -4343,8 +4088,6 @@ ves_icall_System_Reflection_Assembly_get_global_assembly_cache (MonoReflectionAs { MonoAssembly *mass = assembly->assembly; - MONO_ARCH_SAVE_REGS; - return mass->in_gac; } @@ -4355,8 +4098,6 @@ ves_icall_System_Reflection_Assembly_load_with_partial_name (MonoString *mname, MonoAssembly *res; MonoImageOpenStatus status; - MONO_ARCH_SAVE_REGS; - name = mono_string_to_utf8 (mname); res = mono_assembly_load_with_partial_name (name, &status); @@ -4373,8 +4114,6 @@ ves_icall_System_Reflection_Assembly_get_location (MonoReflectionAssembly *assem MonoDomain *domain = mono_object_domain (assembly); MonoString *res; - MONO_ARCH_SAVE_REGS; - res = mono_string_new (domain, mono_image_get_filename (assembly->assembly->image)); return res; @@ -4383,8 +4122,6 @@ ves_icall_System_Reflection_Assembly_get_location (MonoReflectionAssembly *assem ICALL_EXPORT MonoBoolean ves_icall_System_Reflection_Assembly_get_ReflectionOnly (MonoReflectionAssembly *assembly) { - MONO_ARCH_SAVE_REGS; - return assembly->assembly->ref_only; } @@ -4393,21 +4130,22 @@ ves_icall_System_Reflection_Assembly_InternalImageRuntimeVersion (MonoReflection { MonoDomain *domain = mono_object_domain (assembly); - MONO_ARCH_SAVE_REGS; - return mono_string_new (domain, assembly->assembly->image->version); } ICALL_EXPORT MonoReflectionMethod* ves_icall_System_Reflection_Assembly_get_EntryPoint (MonoReflectionAssembly *assembly) { + MonoError error; + MonoMethod *method; guint32 token = mono_image_get_entry_point (assembly->assembly->image); - MONO_ARCH_SAVE_REGS; - if (!token) return NULL; - return mono_method_get_object (mono_object_domain (assembly), mono_get_method (assembly->assembly->image, token, NULL), NULL); + method = mono_get_method_checked (assembly->assembly->image, token, NULL, NULL, &error); + mono_error_raise_exception (&error); + + return mono_method_get_object (mono_object_domain (assembly), method, NULL); } ICALL_EXPORT MonoReflectionModule* @@ -4424,8 +4162,6 @@ ves_icall_System_Reflection_Assembly_GetManifestResourceNames (MonoReflectionAss int i; const char *val; - MONO_ARCH_SAVE_REGS; - for (i = 0; i < table->rows; ++i) { val = mono_metadata_string_heap (assembly->assembly->image, mono_metadata_decode_row_col (table, i, MONO_MANIFEST_NAME)); mono_array_setref (result, i, mono_string_new (mono_object_domain (assembly), val)); @@ -4474,8 +4210,6 @@ ves_icall_System_Reflection_Assembly_GetReferencedAssemblies (MonoReflectionAsse MonoImage *image = assembly->assembly->image; MonoTableInfo *t; - MONO_ARCH_SAVE_REGS; - if (!System_Reflection_AssemblyName) System_Reflection_AssemblyName = mono_class_from_name ( mono_defaults.corlib, "System.Reflection", "AssemblyName"); @@ -4574,8 +4308,6 @@ ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (MonoReflection const char *val; MonoImage *module; - MONO_ARCH_SAVE_REGS; - for (i = 0; i < table->rows; ++i) { mono_metadata_decode_row (table, i, cols, MONO_MANIFEST_SIZE); val = mono_metadata_string_heap (assembly->assembly->image, cols [MONO_MANIFEST_NAME]); @@ -4617,8 +4349,6 @@ ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (MonoReflec const char *val; char *n; - MONO_ARCH_SAVE_REGS; - n = mono_string_to_utf8 (name); for (i = 0; i < table->rows; ++i) { mono_metadata_decode_row (table, i, cols, MONO_MANIFEST_SIZE); @@ -4654,7 +4384,8 @@ ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (MonoReflec char *msg = g_strdup_printf ("Assembly %d referenced from assembly %s not found ", i - 1, assembly->assembly->image->name); MonoException *ex = mono_get_exception_file_not_found2 (msg, NULL); g_free (msg); - mono_raise_exception (ex); + mono_set_pending_exception (ex); + return FALSE; } MONO_OBJECT_SETREF (info, assembly, mono_assembly_get_object (mono_domain_get (), assembly->assembly->image->references [i - 1])); @@ -4681,8 +4412,6 @@ ves_icall_System_Reflection_Assembly_GetFilesInternal (MonoReflectionAssembly *a const char *val; char *n; - MONO_ARCH_SAVE_REGS; - /* check hash if needed */ if (name) { n = mono_string_to_utf8 (name); @@ -4768,7 +4497,8 @@ ves_icall_System_Reflection_Assembly_GetModulesInternal (MonoReflectionAssembly MonoImage *m = mono_image_load_file_for_image (image, i + 1); if (!m) { MonoString *fname = mono_string_new (mono_domain_get (), mono_metadata_string_heap (image, cols [MONO_FILE_NAME])); - mono_raise_exception (mono_get_exception_file_not_found2 (NULL, fname)); + mono_set_pending_exception (mono_get_exception_file_not_found2 (NULL, fname)); + return NULL; } mono_array_setref (res, j, mono_module_get_object (domain, m)); } @@ -4794,6 +4524,8 @@ mono_method_get_equivalent_method (MonoMethod *method, MonoClass *klass) { int offset = -1, i; if (method->is_inflated && ((MonoMethodInflated*)method)->context.method_inst) { + MonoError error; + MonoMethod *result; MonoMethodInflated *inflated = (MonoMethodInflated*)method; //method is inflated, we should inflate it on the other class MonoGenericContext ctx; @@ -4803,7 +4535,9 @@ mono_method_get_equivalent_method (MonoMethod *method, MonoClass *klass) ctx.class_inst = klass->generic_class->context.class_inst; else if (klass->generic_container) ctx.class_inst = klass->generic_container->context.class_inst; - return mono_class_inflate_generic_method_full (inflated->declaring, klass, &ctx); + result = mono_class_inflate_generic_method_full_checked (inflated->declaring, klass, &ctx, &error); + g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */ + return result; } mono_class_setup_methods (method->klass); @@ -4835,15 +4569,9 @@ ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternalType (MonoMeth if (!method) return NULL; } - } else - klass = method->klass; - return mono_method_get_object (mono_domain_get (), method, klass); -} - -ICALL_EXPORT MonoReflectionMethod* -ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternal (MonoMethod *method) -{ - return mono_method_get_object (mono_domain_get (), method, NULL); + } else + klass = method->klass; + return mono_method_get_object (mono_domain_get (), method, klass); } ICALL_EXPORT MonoReflectionMethodBody* @@ -4857,8 +4585,6 @@ ves_icall_System_Reflection_Assembly_GetExecutingAssembly (void) { MonoMethod *dest = NULL; - MONO_ARCH_SAVE_REGS; - mono_stack_walk_no_il (get_executing, &dest); g_assert (dest); return mono_assembly_get_object (mono_domain_get (), dest->klass->image->assembly); @@ -4870,8 +4596,6 @@ ves_icall_System_Reflection_Assembly_GetEntryAssembly (void) { MonoDomain* domain = mono_domain_get (); - MONO_ARCH_SAVE_REGS; - if (!domain->entry_assembly) return NULL; @@ -4884,8 +4608,6 @@ ves_icall_System_Reflection_Assembly_GetCallingAssembly (void) MonoMethod *m; MonoMethod *dest; - MONO_ARCH_SAVE_REGS; - dest = NULL; mono_stack_walk_no_il (get_executing, &dest); m = dest; @@ -4927,13 +4649,27 @@ ves_icall_System_MonoType_getFullName (MonoReflectionType *object, gboolean full } ICALL_EXPORT int -vell_icall_MonoType_get_core_clr_security_level (MonoReflectionType *this) +vell_icall_MonoType_get_core_clr_security_level (MonoReflectionType *rfield) { - MonoClass *klass = mono_class_from_mono_type (this->type); + MonoClass *klass = mono_class_from_mono_type (rfield->type); mono_class_init_or_throw (klass); return mono_security_core_clr_class_level (klass); } +ICALL_EXPORT int +ves_icall_MonoField_get_core_clr_security_level (MonoReflectionField *rfield) +{ + MonoClassField *field = rfield->field; + return mono_security_core_clr_field_level (field, TRUE); +} + +ICALL_EXPORT int +ves_icall_MonoMethod_get_core_clr_security_level (MonoReflectionMethod *rfield) +{ + MonoMethod *method = rfield->method; + return mono_security_core_clr_method_level (method, TRUE); +} + static void fill_reflection_assembly_name (MonoDomain *domain, MonoReflectionAssemblyName *aname, MonoAssemblyName *name, const char *absolute, gboolean by_default_version, gboolean default_publickey, gboolean default_token) { @@ -4944,8 +4680,6 @@ fill_reflection_assembly_name (MonoDomain *domain, MonoReflectionAssemblyName *a gchar *codebase; MonoBoolean assembly_ref = 0; - MONO_ARCH_SAVE_REGS; - MONO_OBJECT_SETREF (aname, name, mono_string_new (domain, name->name)); aname->major = name->major; aname->minor = name->minor; @@ -5054,8 +4788,6 @@ ves_icall_System_Reflection_Assembly_FillName (MonoReflectionAssembly *assembly, gchar *absolute; MonoAssembly *mass = assembly->assembly; - MONO_ARCH_SAVE_REGS; - if (g_path_is_absolute (mass->image->name)) { fill_reflection_assembly_name (mono_object_domain (assembly), aname, &mass->aname, mass->image->name, TRUE, @@ -5079,9 +4811,7 @@ ves_icall_System_Reflection_Assembly_InternalGetAssemblyName (MonoString *fname, gboolean res; MonoImage *image; MonoAssemblyName name; - char *dirname - - MONO_ARCH_SAVE_REGS; + char *dirname; filename = mono_string_to_utf8 (fname); @@ -5099,14 +4829,16 @@ ves_icall_System_Reflection_Assembly_InternalGetAssemblyName (MonoString *fname, exc = mono_get_exception_bad_image_format2 (NULL, fname); else exc = mono_get_exception_file_not_found2 (NULL, fname); - mono_raise_exception (exc); + mono_set_pending_exception (exc); + return; } res = mono_assembly_fill_assembly_name (image, &name); if (!res) { mono_image_close (image); g_free (filename); - mono_raise_exception (mono_get_exception_argument ("assemblyFile", "The file does not contain a manifest")); + mono_set_pending_exception (mono_get_exception_argument ("assemblyFile", "The file does not contain a manifest")); + return; } fill_reflection_assembly_name (mono_domain_get (), aname, &name, filename, @@ -5145,6 +4877,21 @@ ves_icall_System_Reflection_Assembly_LoadPermissions (MonoReflectionAssembly *as return result; } +static gboolean +mono_module_type_is_visible (MonoTableInfo *tdef, MonoImage *image, int type) +{ + guint32 attrs, visibility; + do { + attrs = mono_metadata_decode_row_col (tdef, type - 1, MONO_TYPEDEF_FLAGS); + visibility = attrs & TYPE_ATTRIBUTE_VISIBILITY_MASK; + if (visibility != TYPE_ATTRIBUTE_PUBLIC && visibility != TYPE_ATTRIBUTE_NESTED_PUBLIC) + return FALSE; + + } while ((type = mono_metadata_token_index (mono_metadata_nested_in_typedef (image, type)))); + + return TRUE; +} + static MonoArray* mono_module_get_types (MonoDomain *domain, MonoImage *image, MonoArray **exceptions, MonoBoolean exportedOnly) { @@ -5152,15 +4899,12 @@ mono_module_get_types (MonoDomain *domain, MonoImage *image, MonoArray **excepti MonoClass *klass; MonoTableInfo *tdef = &image->tables [MONO_TABLE_TYPEDEF]; int i, count; - guint32 attrs, visibility; /* we start the count from 1 because we skip the special type */ if (exportedOnly) { count = 0; for (i = 1; i < tdef->rows; ++i) { - attrs = mono_metadata_decode_row_col (tdef, i, MONO_TYPEDEF_FLAGS); - visibility = attrs & TYPE_ATTRIBUTE_VISIBILITY_MASK; - if (visibility == TYPE_ATTRIBUTE_PUBLIC || visibility == TYPE_ATTRIBUTE_NESTED_PUBLIC) + if (mono_module_type_is_visible (tdef, image, i + 1)) count++; } } else { @@ -5170,12 +4914,10 @@ mono_module_get_types (MonoDomain *domain, MonoImage *image, MonoArray **excepti *exceptions = mono_array_new (domain, mono_defaults.exception_class, count); count = 0; for (i = 1; i < tdef->rows; ++i) { - attrs = mono_metadata_decode_row_col (tdef, i, MONO_TYPEDEF_FLAGS); - visibility = attrs & TYPE_ATTRIBUTE_VISIBILITY_MASK; - if (!exportedOnly || (visibility == TYPE_ATTRIBUTE_PUBLIC || visibility == TYPE_ATTRIBUTE_NESTED_PUBLIC)) { + if (!exportedOnly || mono_module_type_is_visible (tdef, image, i + 1)) { MonoError error; klass = mono_class_get_checked (image, (i + 1) | MONO_TOKEN_TYPE_DEF, &error); - g_assert (!mono_loader_get_last_error ()); /* Plug any leaks */ + mono_loader_assert_no_error (); /* Plug any leaks */ if (klass) { mono_array_setref (res, count, mono_type_get_object (domain, &klass->byval_arg)); @@ -5201,8 +4943,6 @@ ves_icall_System_Reflection_Assembly_GetTypes (MonoReflectionAssembly *assembly, GList *list = NULL; int i, len, ex_count; - MONO_ARCH_SAVE_REGS; - domain = mono_object_domain (assembly); g_assert (!assembly_is_dynamic (assembly->assembly)); @@ -5292,7 +5032,8 @@ ves_icall_System_Reflection_Assembly_GetTypes (MonoReflectionAssembly *assembly, exc = mono_get_exception_reflection_type_load (res, exl); mono_loader_clear_error (); - mono_raise_exception (exc); + mono_set_pending_exception (exc); + return NULL; } return res; @@ -5332,8 +5073,6 @@ ves_icall_System_Reflection_Module_GetGlobalType (MonoReflectionModule *module) MonoDomain *domain = mono_object_domain (module); MonoClass *klass; - MONO_ARCH_SAVE_REGS; - g_assert (module->image); if (image_is_dynamic (module->image) && ((MonoDynamicImage*)(module->image))->initial_image) @@ -5357,8 +5096,6 @@ ves_icall_System_Reflection_Module_GetGuidInternal (MonoReflectionModule *module { MonoDomain *domain = mono_object_domain (module); - MONO_ARCH_SAVE_REGS; - g_assert (module->image); return mono_string_new (domain, module->image->guid); } @@ -5400,16 +5137,16 @@ ves_icall_System_Reflection_Module_InternalGetTypes (MonoReflectionModule *modul MonoArray *exceptions; int i; - MONO_ARCH_SAVE_REGS; - if (!module->image) return mono_array_new (mono_object_domain (module), mono_defaults.monotype_class, 0); else { MonoArray *res = mono_module_get_types (mono_object_domain (module), module->image, &exceptions, FALSE); for (i = 0; i < mono_array_length (exceptions); ++i) { MonoException *ex = mono_array_get (exceptions, MonoException *, i); - if (ex) - mono_raise_exception (ex); + if (ex) { + mono_set_pending_exception (ex); + return NULL; + } } return res; } @@ -5497,19 +5234,20 @@ ves_icall_System_Reflection_Module_ResolveTypeToken (MonoImage *image, guint32 t } ICALL_EXPORT MonoMethod* -ves_icall_System_Reflection_Module_ResolveMethodToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error) +ves_icall_System_Reflection_Module_ResolveMethodToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *resolve_error) { + MonoError error; int table = mono_metadata_token_table (token); int index = mono_metadata_token_index (token); MonoGenericContext context; MonoMethod *method; - *error = ResolveTokenError_Other; + *resolve_error = ResolveTokenError_Other; /* Validate token */ if ((table != MONO_TABLE_METHOD) && (table != MONO_TABLE_METHODSPEC) && (table != MONO_TABLE_MEMBERREF)) { - *error = ResolveTokenError_BadTable; + *resolve_error = ResolveTokenError_BadTable; return NULL; } @@ -5518,7 +5256,7 @@ ves_icall_System_Reflection_Module_ResolveMethodToken (MonoImage *image, guint32 return mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL); if ((table == MONO_TABLE_MEMBERREF) && !(mono_memberref_is_method (image, token))) { - *error = ResolveTokenError_BadTable; + *resolve_error = ResolveTokenError_BadTable; return NULL; } @@ -5527,19 +5265,17 @@ ves_icall_System_Reflection_Module_ResolveMethodToken (MonoImage *image, guint32 } if ((index <= 0) || (index > image->tables [table].rows)) { - *error = ResolveTokenError_OutOfRange; + *resolve_error = ResolveTokenError_OutOfRange; return NULL; } if ((table == MONO_TABLE_MEMBERREF) && (!mono_memberref_is_method (image, token))) { - *error = ResolveTokenError_BadTable; + *resolve_error = ResolveTokenError_BadTable; return NULL; } init_generic_context_from_args (&context, type_args, method_args); - method = mono_get_method_full (image, token, NULL, &context); - - if (mono_loader_get_last_error ()) - mono_raise_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ())); + method = mono_get_method_checked (image, token, NULL, &context, &error); + mono_error_raise_exception (&error); return method; } @@ -5714,8 +5450,6 @@ ves_icall_ModuleBuilder_create_modified_type (MonoReflectionTypeBuilder *tb, Mon char *str = mono_string_to_utf8 (smodifiers); char *p; - MONO_ARCH_SAVE_REGS; - klass = mono_class_from_mono_type (tb->type.type); p = str; /* logic taken from mono_reflection_parse_type(): keep in sync */ @@ -5772,8 +5506,6 @@ ves_icall_Type_IsArrayImpl (MonoReflectionType *t) MonoType *type; MonoBoolean res; - MONO_ARCH_SAVE_REGS; - type = t->type; res = !type->byref && (type->type == MONO_TYPE_ARRAY || type->type == MONO_TYPE_SZARRAY); @@ -5799,8 +5531,6 @@ ves_icall_Type_make_array_type (MonoReflectionType *type, int rank) { MonoClass *klass, *aklass; - MONO_ARCH_SAVE_REGS; - klass = mono_class_from_mono_type (type->type); check_for_invalid_type (klass); @@ -5817,8 +5547,6 @@ ves_icall_Type_make_byref_type (MonoReflectionType *type) { MonoClass *klass; - MONO_ARCH_SAVE_REGS; - klass = mono_class_from_mono_type (type->type); mono_class_init_or_throw (klass); check_for_invalid_type (klass); @@ -5849,8 +5577,6 @@ ves_icall_System_Delegate_CreateDelegate_internal (MonoReflectionType *type, Mon gpointer func; MonoMethod *method = info->method; - MONO_ARCH_SAVE_REGS; - mono_class_init_or_throw (delegate_class); mono_assert (delegate_class->parent == mono_defaults.multicastdelegate_class); @@ -5877,267 +5603,23 @@ ves_icall_System_Delegate_CreateDelegate_internal (MonoReflectionType *type, Mon return delegate; } -ICALL_EXPORT void -ves_icall_System_Delegate_SetMulticastInvoke (MonoDelegate *this) -{ - /* Reset the invoke impl to the default one */ - this->invoke_impl = mono_runtime_create_delegate_trampoline (this->object.vtable->klass); -} - -/* - * Magic number to convert a time which is relative to - * Jan 1, 1970 into a value which is relative to Jan 1, 0001. - */ -#define EPOCH_ADJUST ((guint64)62135596800LL) - -/* - * Magic number to convert FILETIME base Jan 1, 1601 to DateTime - base Jan, 1, 0001 - */ -#define FILETIME_ADJUST ((guint64)504911232000000000LL) - -#ifdef HOST_WIN32 -/* convert a SYSTEMTIME which is of the form "last thursday in october" to a real date */ -static void -convert_to_absolute_date(SYSTEMTIME *date) +ICALL_EXPORT MonoMulticastDelegate * +ves_icall_System_Delegate_AllocDelegateLike_internal (MonoDelegate *delegate) { -#define IS_LEAP(y) ((y % 4) == 0 && ((y % 100) != 0 || (y % 400) == 0)) - static int days_in_month[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; - static int leap_days_in_month[] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; - /* from the calendar FAQ */ - int a = (14 - date->wMonth) / 12; - int y = date->wYear - a; - int m = date->wMonth + 12 * a - 2; - int d = (1 + y + y/4 - y/100 + y/400 + (31*m)/12) % 7; + MonoMulticastDelegate *ret; - /* d is now the day of the week for the first of the month (0 == Sunday) */ + g_assert (mono_class_has_parent (mono_object_class (delegate), mono_defaults.multicastdelegate_class)); - int day_of_week = date->wDayOfWeek; + ret = (MonoMulticastDelegate*) mono_object_new (mono_object_domain (delegate), mono_object_class (delegate)); + ret->delegate.invoke_impl = mono_runtime_create_delegate_trampoline (mono_object_class (delegate)); - /* set day_in_month to the first day in the month which falls on day_of_week */ - int day_in_month = 1 + (day_of_week - d); - if (day_in_month <= 0) - day_in_month += 7; - - /* wDay is 1 for first weekday in month, 2 for 2nd ... 5 means last - so work that out allowing for days in the month */ - date->wDay = day_in_month + (date->wDay - 1) * 7; - if (date->wDay > (IS_LEAP(date->wYear) ? leap_days_in_month[date->wMonth - 1] : days_in_month[date->wMonth - 1])) - date->wDay -= 7; + return ret; } -#endif -#ifndef HOST_WIN32 -/* - * Return's the offset from GMT of a local time. - * - * tm is a local time - * t is the same local time as seconds. - */ -static int -gmt_offset(struct tm *tm, time_t t) -{ -#if defined (HAVE_TM_GMTOFF) - return tm->tm_gmtoff; -#else - struct tm g; - time_t t2; - g = *gmtime(&t); - g.tm_isdst = tm->tm_isdst; - t2 = mktime(&g); - return (int)difftime(t, t2); -#endif -} -#endif -/* - * This is heavily based on zdump.c from glibc 2.2. - * - * * data[0]: start of daylight saving time (in DateTime ticks). - * * data[1]: end of daylight saving time (in DateTime ticks). - * * data[2]: utcoffset (in TimeSpan ticks). - * * data[3]: additional offset when daylight saving (in TimeSpan ticks). - * * name[0]: name of this timezone when not daylight saving. - * * name[1]: name of this timezone when daylight saving. - * - * FIXME: This only works with "standard" Unix dates (years between 1900 and 2100) while - * the class library allows years between 1 and 9999. - * - * Returns true on success and zero on failure. - */ -ICALL_EXPORT guint32 -ves_icall_System_CurrentSystemTimeZone_GetTimeZoneData (guint32 year, MonoArray **data, MonoArray **names) +ICALL_EXPORT MonoReflectionMethod* +ves_icall_System_Delegate_GetVirtualMethod_internal (MonoDelegate *delegate) { -#ifndef HOST_WIN32 - MonoDomain *domain = mono_domain_get (); - struct tm start, tt; - time_t t; - - long int gmtoff, gmtoff_after, gmtoff_st, gmtoff_ds; - int day, transitioned; - char tzone [64]; - - gmtoff_st = gmtoff_ds = transitioned = 0; - - MONO_ARCH_SAVE_REGS; - - MONO_CHECK_ARG_NULL (data); - MONO_CHECK_ARG_NULL (names); - - mono_gc_wbarrier_generic_store (data, (MonoObject*) mono_array_new (domain, mono_defaults.int64_class, 4)); - mono_gc_wbarrier_generic_store (names, (MonoObject*) mono_array_new (domain, mono_defaults.string_class, 2)); - - /* - * no info is better than crashing: we'll need our own tz data - * to make this work properly, anyway. The range is probably - * reduced to 1970 .. 2037 because that is what mktime is - * guaranteed to support (we get into an infinite loop - * otherwise). - */ - - memset (&start, 0, sizeof (start)); - - start.tm_mday = 1; - start.tm_year = year-1900; - - t = mktime (&start); - - if ((year < 1970) || (year > 2037) || (t == -1)) { - t = time (NULL); - tt = *localtime (&t); - strftime (tzone, sizeof (tzone), "%Z", &tt); - mono_array_setref ((*names), 0, mono_string_new (domain, tzone)); - mono_array_setref ((*names), 1, mono_string_new (domain, tzone)); - return 1; - } - - gmtoff = gmt_offset (&start, t); - - /* For each day of the year, calculate the tm_gmtoff. */ - for (day = 0; day < 365 && transitioned < 2; day++) { - - t += 3600*24; - tt = *localtime (&t); - - gmtoff_after = gmt_offset(&tt, t); - - /* Daylight saving starts or ends here. */ - if (gmtoff_after != gmtoff) { - struct tm tt1; - time_t t1; - - /* Try to find the exact hour when daylight saving starts/ends. */ - t1 = t; - do { - t1 -= 3600; - tt1 = *localtime (&t1); - } while (gmt_offset (&tt1, t1) != gmtoff); - - /* Try to find the exact minute when daylight saving starts/ends. */ - do { - t1 += 60; - tt1 = *localtime (&t1); - } while (gmt_offset (&tt1, t1) == gmtoff); - t1+=gmtoff; - strftime (tzone, sizeof (tzone), "%Z", &tt); - - /* Write data, if we're already in daylight saving, we're done. */ - if (tt.tm_isdst) { - mono_array_setref ((*names), 1, mono_string_new (domain, tzone)); - mono_array_set ((*data), gint64, 0, ((gint64)t1 + EPOCH_ADJUST) * 10000000L); - if (gmtoff_ds == 0) { - gmtoff_st = gmtoff; - gmtoff_ds = gmtoff_after; - } - transitioned++; - } else { - time_t te; - te = mktime (&tt); - - mono_array_setref ((*names), 0, mono_string_new (domain, tzone)); - mono_array_set ((*data), gint64, 1, ((gint64)t1 + EPOCH_ADJUST) * 10000000L); - if (gmtoff_ds == 0) { - gmtoff_st = gmtoff_after; - gmtoff_ds = gmtoff; - } - transitioned++; - } - - /* This is only set once when we enter daylight saving. */ - if (tt1.tm_isdst) { - mono_array_set ((*data), gint64, 2, (gint64)gmtoff_st * 10000000L); - mono_array_set ((*data), gint64, 3, (gint64)(gmtoff_ds - gmtoff_st) * 10000000L); - } - gmtoff = gmt_offset (&tt, t); - } - } - - if (transitioned < 2) { - strftime (tzone, sizeof (tzone), "%Z", &tt); - mono_array_setref ((*names), 0, mono_string_new (domain, tzone)); - mono_array_setref ((*names), 1, mono_string_new (domain, tzone)); - mono_array_set ((*data), gint64, 0, 0); - mono_array_set ((*data), gint64, 1, 0); - mono_array_set ((*data), gint64, 2, (gint64) gmtoff * 10000000L); - mono_array_set ((*data), gint64, 3, 0); - } - - return 1; -#else - MonoDomain *domain = mono_domain_get (); - TIME_ZONE_INFORMATION tz_info; - FILETIME ft; - int i; - int err, tz_id; - - tz_id = GetTimeZoneInformation (&tz_info); - if (tz_id == TIME_ZONE_ID_INVALID) - return 0; - - MONO_CHECK_ARG_NULL (data); - MONO_CHECK_ARG_NULL (names); - - mono_gc_wbarrier_generic_store (data, mono_array_new (domain, mono_defaults.int64_class, 4)); - mono_gc_wbarrier_generic_store (names, mono_array_new (domain, mono_defaults.string_class, 2)); - - for (i = 0; i < 32; ++i) - if (!tz_info.DaylightName [i]) - break; - mono_array_setref ((*names), 1, mono_string_new_utf16 (domain, tz_info.DaylightName, i)); - for (i = 0; i < 32; ++i) - if (!tz_info.StandardName [i]) - break; - mono_array_setref ((*names), 0, mono_string_new_utf16 (domain, tz_info.StandardName, i)); - - if ((year <= 1601) || (year > 30827)) { - /* - * According to MSDN, the MS time functions can't handle dates outside - * this interval. - */ - return 1; - } - - /* even if the timezone has no daylight savings it may have Bias (e.g. GMT+13 it seems) */ - if (tz_id != TIME_ZONE_ID_UNKNOWN) { - tz_info.StandardDate.wYear = year; - convert_to_absolute_date(&tz_info.StandardDate); - err = SystemTimeToFileTime (&tz_info.StandardDate, &ft); - //g_assert(err); - if (err == 0) - return 0; - - mono_array_set ((*data), gint64, 1, FILETIME_ADJUST + (((guint64)ft.dwHighDateTime<<32) | ft.dwLowDateTime)); - tz_info.DaylightDate.wYear = year; - convert_to_absolute_date(&tz_info.DaylightDate); - err = SystemTimeToFileTime (&tz_info.DaylightDate, &ft); - //g_assert(err); - if (err == 0) - return 0; - - mono_array_set ((*data), gint64, 0, FILETIME_ADJUST + (((guint64)ft.dwHighDateTime<<32) | ft.dwLowDateTime)); - } - mono_array_set ((*data), gint64, 2, (tz_info.Bias + tz_info.StandardBias) * -600000000LL); - mono_array_set ((*data), gint64, 3, (tz_info.DaylightBias - tz_info.StandardBias) * -600000000LL); - - return 1; -#endif + return mono_method_get_object (mono_domain_get (), mono_object_get_virtual_method (delegate->target, delegate->method), mono_object_class (delegate->target)); } /* System.Buffer */ @@ -6187,24 +5669,18 @@ mono_array_get_byte_length (MonoArray *array) ICALL_EXPORT gint32 ves_icall_System_Buffer_ByteLengthInternal (MonoArray *array) { - MONO_ARCH_SAVE_REGS; - return mono_array_get_byte_length (array); } ICALL_EXPORT gint8 ves_icall_System_Buffer_GetByteInternal (MonoArray *array, gint32 idx) { - MONO_ARCH_SAVE_REGS; - return mono_array_get (array, gint8, idx); } ICALL_EXPORT void ves_icall_System_Buffer_SetByteInternal (MonoArray *array, gint32 idx, gint8 value) { - MONO_ARCH_SAVE_REGS; - mono_array_set (array, gint8, idx, value); } @@ -6213,11 +5689,16 @@ ves_icall_System_Buffer_BlockCopyInternal (MonoArray *src, gint32 src_offset, Mo { guint8 *src_buf, *dest_buf; - MONO_ARCH_SAVE_REGS; + if (count < 0) { + mono_set_pending_exception (mono_get_exception_argument ("count", "is negative")); + return FALSE; + } + + g_assert (count >= 0); /* This is called directly from the class libraries without going through the managed wrapper */ - MONO_CHECK_ARG_NULL (src); - MONO_CHECK_ARG_NULL (dest); + MONO_CHECK_ARG_NULL (src, FALSE); + MONO_CHECK_ARG_NULL (dest, FALSE); /* watch out for integer overflow */ if ((src_offset > mono_array_get_byte_length (src) - count) || (dest_offset > mono_array_get_byte_length (dest) - count)) @@ -6236,17 +5717,15 @@ ves_icall_System_Buffer_BlockCopyInternal (MonoArray *src, gint32 src_offset, Mo #ifndef DISABLE_REMOTING ICALL_EXPORT MonoObject * -ves_icall_Remoting_RealProxy_GetTransparentProxy (MonoObject *this, MonoString *class_name) +ves_icall_Remoting_RealProxy_GetTransparentProxy (MonoObject *this_obj, MonoString *class_name) { - MonoDomain *domain = mono_object_domain (this); + MonoDomain *domain = mono_object_domain (this_obj); MonoObject *res; - MonoRealProxy *rp = ((MonoRealProxy *)this); + MonoRealProxy *rp = ((MonoRealProxy *)this_obj); MonoTransparentProxy *tp; MonoType *type; MonoClass *klass; - MONO_ARCH_SAVE_REGS; - res = mono_object_new (domain, mono_defaults.transparent_proxy_class); tp = (MonoTransparentProxy*) res; @@ -6254,7 +5733,7 @@ ves_icall_Remoting_RealProxy_GetTransparentProxy (MonoObject *this, MonoString * type = ((MonoReflectionType *)rp->class_to_proxy)->type; klass = mono_class_from_mono_type (type); - tp->custom_type_info = (mono_object_isinst (this, mono_defaults.iremotingtypeinfo_class) != NULL); + tp->custom_type_info = (mono_object_isinst (this_obj, mono_defaults.iremotingtypeinfo_class) != NULL); tp->remote_class = mono_remote_class (domain, class_name, klass); res->vtable = mono_remote_class_vtable (domain, tp->remote_class, rp); @@ -6273,8 +5752,6 @@ ves_icall_Remoting_RealProxy_InternalGetProxyType (MonoTransparentProxy *tp) MonoString* ves_icall_System_Environment_get_UserName (void) { - MONO_ARCH_SAVE_REGS; - /* using glib is more portable */ return mono_string_new (mono_domain_get (), g_get_user_name ()); } @@ -6337,8 +5814,6 @@ ves_icall_System_Environment_get_Platform (void) ICALL_EXPORT MonoString * ves_icall_System_Environment_get_NewLine (void) { - MONO_ARCH_SAVE_REGS; - #if defined (HOST_WIN32) return mono_string_new (mono_domain_get (), "\r\n"); #else @@ -6352,8 +5827,6 @@ ves_icall_System_Environment_GetEnvironmentVariable (MonoString *name) const gchar *value; gchar *utf8_name; - MONO_ARCH_SAVE_REGS; - if (name == NULL) return NULL; @@ -6373,7 +5846,7 @@ ves_icall_System_Environment_GetEnvironmentVariable (MonoString *name) */ #ifndef _MSC_VER #ifndef __MINGW32_VERSION -#if defined(__APPLE__) && !defined (__arm__) +#if defined(__APPLE__) && !defined (__arm__) && !defined (__aarch64__) /* Apple defines this in crt_externs.h but doesn't provide that header for * arm-apple-darwin9. We'll manually define the symbol on Apple as it does * in fact exist on all implementations (so far) @@ -6445,8 +5918,6 @@ ves_icall_System_Environment_GetEnvironmentVariableNames (void) gchar **e, **parts; int n; - MONO_ARCH_SAVE_REGS; - n = 0; for (e = environ; *e != 0; ++ e) ++ n; @@ -6489,8 +5960,6 @@ ves_icall_System_Environment_InternalSetEnvironmentVariable (MonoString *name, M MonoError error; #endif - MONO_ARCH_SAVE_REGS; - #ifdef HOST_WIN32 utf16_name = mono_string_to_utf16 (name); if ((value == NULL) || (mono_string_length (value) == 0) || (mono_string_chars (value)[0] == 0)) { @@ -6529,8 +5998,6 @@ ves_icall_System_Environment_InternalSetEnvironmentVariable (MonoString *name, M ICALL_EXPORT void ves_icall_System_Environment_Exit (int result) { - MONO_ARCH_SAVE_REGS; - mono_environment_exitcode_set (result); /* FIXME: There are some cleanup hangs that should be worked out, but @@ -6591,9 +6058,7 @@ ves_icall_System_Environment_GetLogicalDrives (void) MonoDomain *domain = mono_domain_get (); gint len; - MONO_ARCH_SAVE_REGS; - - buf [0] = '\0'; + buf [0] = '\0'; ptr = buf; while (size > initial_size) { @@ -6646,8 +6111,6 @@ ves_icall_System_IO_DriveInfo_GetDriveFormat (MonoString *path) ICALL_EXPORT MonoString * ves_icall_System_Environment_InternalGetHome (void) { - MONO_ARCH_SAVE_REGS; - return mono_string_new (mono_domain_get (), g_get_home_dir ()); } @@ -6679,7 +6142,7 @@ static const char *encodings [] = { * returns the code page as a string */ ICALL_EXPORT MonoString* -ves_icall_System_Text_Encoding_InternalCodePage (gint32 *int_code_page) +ves_icall_System_Text_EncodingHelper_InternalCodePage (gint32 *int_code_page) { const char *cset; const char *p; @@ -6690,7 +6153,6 @@ ves_icall_System_Text_Encoding_InternalCodePage (gint32 *int_code_page) int i; *int_code_page = -1; - MONO_ARCH_SAVE_REGS; g_get_charset (&cset); c = codepage = strdup (cset); @@ -6706,7 +6168,7 @@ ves_icall_System_Text_Encoding_InternalCodePage (gint32 *int_code_page) p = encodings [0]; code = 0; for (i = 0; p != 0; ){ - if ((gssize) p < 7){ + if ((gsize) p < 7){ code = (gssize) p; p = encodings [++i]; continue; @@ -6748,22 +6210,24 @@ ves_icall_System_Environment_BroadcastSettingChange (void) #endif } +ICALL_EXPORT gint32 +ves_icall_System_Runtime_Versioning_VersioningHelper_GetRuntimeId (void) +{ + return 9; +} + ICALL_EXPORT void -ves_icall_MonoMethodMessage_InitMessage (MonoMethodMessage *this, +ves_icall_MonoMethodMessage_InitMessage (MonoMethodMessage *this_obj, MonoReflectionMethod *method, MonoArray *out_args) { - MONO_ARCH_SAVE_REGS; - - mono_message_init (mono_object_domain (this), this, method, out_args); + mono_message_init (mono_object_domain (this_obj), this_obj, method, out_args); } #ifndef DISABLE_REMOTING ICALL_EXPORT MonoBoolean ves_icall_IsTransparentProxy (MonoObject *proxy) { - MONO_ARCH_SAVE_REGS; - if (!proxy) return 0; @@ -6782,8 +6246,8 @@ ves_icall_Remoting_RemotingServices_GetVirtualMethod ( MonoMethod **vtable; MonoMethod *res = NULL; - MONO_CHECK_ARG_NULL (rtype); - MONO_CHECK_ARG_NULL (rmethod); + MONO_CHECK_ARG_NULL (rtype, NULL); + MONO_CHECK_ARG_NULL (rmethod, NULL); method = rmethod->method; klass = mono_class_from_mono_type (rtype->type); @@ -6831,8 +6295,6 @@ ves_icall_System_Runtime_Activation_ActivationServices_EnableProxyActivation (Mo MonoClass *klass; MonoVTable* vtable; - MONO_ARCH_SAVE_REGS; - klass = mono_class_from_mono_type (type->type); vtable = mono_class_vtable_full (mono_domain_get (), klass, TRUE); @@ -6855,14 +6317,14 @@ ves_icall_System_Runtime_Activation_ActivationServices_AllocateUninitializedClas MonoClass *klass; MonoDomain *domain; - MONO_ARCH_SAVE_REGS; - domain = mono_object_domain (type); klass = mono_class_from_mono_type (type->type); mono_class_init_or_throw (klass); - if (MONO_CLASS_IS_INTERFACE (klass) || (klass->flags & TYPE_ATTRIBUTE_ABSTRACT)) - mono_raise_exception (mono_get_exception_argument ("type", "Type cannot be instantiated")); + if (MONO_CLASS_IS_INTERFACE (klass) || (klass->flags & TYPE_ATTRIBUTE_ABSTRACT)) { + mono_set_pending_exception (mono_get_exception_argument ("type", "Type cannot be instantiated")); + return NULL; + } if (klass->rank >= 1) { g_assert (klass->rank == 1); @@ -6876,8 +6338,6 @@ ves_icall_System_Runtime_Activation_ActivationServices_AllocateUninitializedClas ICALL_EXPORT MonoString * ves_icall_System_IO_get_temp_path (void) { - MONO_ARCH_SAVE_REGS; - return mono_string_new (mono_domain_get (), g_get_tmp_dir ()); } @@ -6892,8 +6352,6 @@ ves_icall_System_IO_DriveInfo_GetDiskFreeSpace (MonoString *path_name, guint64 * ULARGE_INTEGER wapi_total_number_of_bytes; ULARGE_INTEGER wapi_total_number_of_free_bytes; - MONO_ARCH_SAVE_REGS; - *error = ERROR_SUCCESS; result = GetDiskFreeSpaceEx (mono_string_chars (path_name), &wapi_free_bytes_avail, &wapi_total_number_of_bytes, &wapi_total_number_of_free_bytes); @@ -6915,8 +6373,6 @@ ves_icall_System_IO_DriveInfo_GetDiskFreeSpace (MonoString *path_name, guint64 * ICALL_EXPORT guint32 ves_icall_System_IO_DriveInfo_GetDriveType (MonoString *root_path_name) { - MONO_ARCH_SAVE_REGS; - return GetDriveType (mono_string_chars (root_path_name)); } #endif @@ -6924,8 +6380,6 @@ ves_icall_System_IO_DriveInfo_GetDriveType (MonoString *root_path_name) ICALL_EXPORT gpointer ves_icall_RuntimeMethod_GetFunctionPointer (MonoMethod *method) { - MONO_ARCH_SAVE_REGS; - return mono_compile_method (method); } @@ -6935,8 +6389,6 @@ ves_icall_System_Configuration_DefaultConfig_get_machine_config_path (void) MonoString *mcpath; gchar *path; - MONO_ARCH_SAVE_REGS; - path = g_build_path (G_DIR_SEPARATOR_S, mono_get_config_dir (), "mono", mono_get_runtime_info ()->framework_version, "machine.config", NULL); #if defined (HOST_WIN32) @@ -6961,14 +6413,12 @@ get_bundled_app_config (void) MonoDomain *domain; MonoString *file; gchar *config_file_name, *config_file_path; - gsize len; + gsize len, config_file_path_length, config_ext_length; gchar *module; - MONO_ARCH_SAVE_REGS; - domain = mono_domain_get (); file = domain->setup->configuration_file; - if (!file) + if (!file || file->length == 0) return NULL; // Retrieve config file and remove the extension @@ -6976,7 +6426,13 @@ get_bundled_app_config (void) config_file_path = mono_portability_find_file (config_file_name, TRUE); if (!config_file_path) config_file_path = config_file_name; - len = strlen (config_file_path) - strlen (".config"); + + config_file_path_length = strlen (config_file_path); + config_ext_length = strlen (".config"); + if (config_file_path_length <= config_ext_length) + return NULL; + + len = config_file_path_length - config_ext_length; module = g_malloc0 (len + 1); memcpy (module, config_file_path, len); // Get the config file from the module name @@ -6998,8 +6454,6 @@ get_bundled_machine_config (void) { const gchar *machine_config; - MONO_ARCH_SAVE_REGS; - machine_config = mono_get_machine_config (); if (!machine_config) @@ -7014,8 +6468,6 @@ ves_icall_System_Web_Util_ICalls_get_machine_install_dir (void) MonoString *ipath; gchar *path; - MONO_ARCH_SAVE_REGS; - path = g_path_get_dirname (mono_get_config_dir ()); #if defined (HOST_WIN32) @@ -7039,8 +6491,6 @@ ves_icall_get_resources_ptr (MonoReflectionAssembly *assembly, gpointer *result, MonoPEResourceDataEntry *entry; MonoImage *image; - MONO_ARCH_SAVE_REGS; - if (!assembly || !result || !size) return FALSE; @@ -7100,8 +6550,6 @@ ves_icall_System_Activator_CreateInstanceInternal (MonoReflectionType *type) MonoClass *klass; MonoDomain *domain; - MONO_ARCH_SAVE_REGS; - domain = mono_object_domain (type); klass = mono_class_from_mono_type (type->type); mono_class_init_or_throw (klass); @@ -7121,8 +6569,6 @@ ves_icall_MonoMethod_get_base_method (MonoReflectionMethod *m, gboolean definiti MonoMethod *result = NULL; int slot; - MONO_ARCH_SAVE_REGS; - if (method->klass == NULL) return m; @@ -7191,8 +6637,6 @@ ves_icall_MonoMethod_get_name (MonoReflectionMethod *m) ICALL_EXPORT void mono_ArgIterator_Setup (MonoArgIterator *iter, char* argsp, char* start) { - MONO_ARCH_SAVE_REGS; - iter->sig = *(MonoMethodSignature**)argsp; g_assert (iter->sig->sentinelpos <= iter->sig->param_count); @@ -7216,7 +6660,6 @@ mono_ArgIterator_IntGetNextArg (MonoArgIterator *iter) guint32 i, arg_size; gint32 align; MonoTypedRef res; - MONO_ARCH_SAVE_REGS; i = iter->sig->sentinelpos + iter->next_arg; @@ -7256,7 +6699,6 @@ mono_ArgIterator_IntGetNextArgT (MonoArgIterator *iter, MonoType *type) guint32 i, arg_size; gint32 align; MonoTypedRef res; - MONO_ARCH_SAVE_REGS; i = iter->sig->sentinelpos + iter->next_arg; @@ -7290,7 +6732,6 @@ ICALL_EXPORT MonoType* mono_ArgIterator_IntGetNextArgType (MonoArgIterator *iter) { gint i; - MONO_ARCH_SAVE_REGS; i = iter->sig->sentinelpos + iter->next_arg; @@ -7300,29 +6741,56 @@ mono_ArgIterator_IntGetNextArgType (MonoArgIterator *iter) } ICALL_EXPORT MonoObject* -mono_TypedReference_ToObject (MonoTypedRef tref) +mono_TypedReference_ToObject (MonoTypedRef* tref) { - MONO_ARCH_SAVE_REGS; - - if (MONO_TYPE_IS_REFERENCE (tref.type)) { - MonoObject** objp = tref.value; + if (MONO_TYPE_IS_REFERENCE (tref->type)) { + MonoObject** objp = tref->value; return *objp; } - return mono_value_box (mono_domain_get (), tref.klass, tref.value); + return mono_value_box (mono_domain_get (), tref->klass, tref->value); } -ICALL_EXPORT MonoObject* -mono_TypedReference_ToObjectInternal (MonoType *type, gpointer value, MonoClass *klass) +ICALL_EXPORT MonoTypedRef +mono_TypedReference_MakeTypedReferenceInternal (MonoObject *target, MonoArray *fields) { - MONO_ARCH_SAVE_REGS; + MonoTypedRef res; + MonoReflectionField *f; + MonoClass *klass; + MonoType *ftype = NULL; + guint8 *p = NULL; + int i; - if (MONO_TYPE_IS_REFERENCE (type)) { - MonoObject** objp = value; - return *objp; + memset (&res, 0, sizeof (res)); + + g_assert (fields); + g_assert (mono_array_length (fields) > 0); + + klass = target->vtable->klass; + + for (i = 0; i < mono_array_length (fields); ++i) { + f = mono_array_get (fields, MonoReflectionField*, i); + if (f == NULL) { + mono_set_pending_exception (mono_get_exception_argument_null ("field")); + return res; + } + if (f->field->parent != klass) { + mono_set_pending_exception (mono_get_exception_argument ("field", "")); + return res; + } + if (i == 0) + p = (guint8*)target + f->field->offset; + else + p += f->field->offset - sizeof (MonoObject); + klass = mono_class_from_mono_type (f->field->type); + ftype = f->field->type; } - return mono_value_box (mono_domain_get (), klass, value); + res.type = ftype; + res.klass = mono_class_from_mono_type (ftype); + res.value = p; + + return res; } static void @@ -7342,7 +6810,6 @@ prelink_method (MonoMethod *method) ICALL_EXPORT void ves_icall_System_Runtime_InteropServices_Marshal_Prelink (MonoReflectionMethod *method) { - MONO_ARCH_SAVE_REGS; prelink_method (method->method); } @@ -7352,7 +6819,6 @@ ves_icall_System_Runtime_InteropServices_Marshal_PrelinkAll (MonoReflectionType MonoClass *klass = mono_class_from_mono_type (type->type); MonoMethod* m; gpointer iter = NULL; - MONO_ARCH_SAVE_REGS; mono_class_init_or_throw (klass); @@ -7377,50 +6843,6 @@ ves_icall_System_NumberFormatter_GetFormatterTables (guint64 const **mantissas, *decHexDigits = Formatter_DecHexDigits; } -ICALL_EXPORT void -get_category_data (int version, - guint8 const **category_data, - guint16 const **category_astral_index) -{ - *category_astral_index = NULL; - -#ifndef DISABLE_NET_4_0 - if (version == 4) { - *category_data = CategoryData_v4; -#ifndef DISABLE_ASTRAL - *category_astral_index = CategoryData_v4_astral_index; -#endif - return; - } -#endif - - *category_data = CategoryData_v2; -#ifndef DISABLE_ASTRAL - *category_astral_index = CategoryData_v2_astral_index; -#endif -} - -/* These parameters are "readonly" in corlib/System/Char.cs */ -ICALL_EXPORT void -ves_icall_System_Char_GetDataTablePointers (int category_data_version, - guint8 const **category_data, - guint16 const **category_astral_index, - guint8 const **numeric_data, - gdouble const **numeric_data_values, - guint16 const **to_lower_data_low, - guint16 const **to_lower_data_high, - guint16 const **to_upper_data_low, - guint16 const **to_upper_data_high) -{ - get_category_data (category_data_version, category_data, category_astral_index); - *numeric_data = NumericData; - *numeric_data_values = NumericDataValues; - *to_lower_data_low = ToLowerDataLow; - *to_lower_data_high = ToLowerDataHigh; - *to_upper_data_low = ToUpperDataLow; - *to_upper_data_high = ToUpperDataHigh; -} - /* * We return NULL for no modifiers so the corlib code can return Type.EmptyTypes * and avoid useless allocations. @@ -7476,7 +6898,8 @@ param_info_get_type_modifiers (MonoReflectionParameter *param, MonoBoolean optio MonoException *ex = mono_get_exception_not_supported (msg); g_free (type_name); g_free (msg); - mono_raise_exception (ex); + mono_set_pending_exception (ex); + return NULL; } image = method->klass->image; @@ -7550,8 +6973,10 @@ property_info_get_default_value (MonoReflectionProperty *property) mono_class_init (prop->parent); - if (!(prop->attrs & PROPERTY_ATTRIBUTE_HAS_DEFAULT)) - mono_raise_exception (mono_get_exception_invalid_operation (NULL)); + if (!(prop->attrs & PROPERTY_ATTRIBUTE_HAS_DEFAULT)) { + mono_set_pending_exception (mono_get_exception_invalid_operation (NULL)); + return NULL; + } def_value = mono_class_get_property_default_value (prop, &def_type); @@ -7593,9 +7018,7 @@ custom_attrs_get_by_type (MonoObject *obj, MonoReflectionType *attr_type) mono_error_raise_exception (&error); if (mono_loader_get_last_error ()) { - mono_raise_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ())); - g_assert_not_reached (); - /* Not reached */ + mono_set_pending_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ())); return NULL; } else { return res; @@ -7633,129 +7056,18 @@ ves_icall_System_ComponentModel_Win32Exception_W32ErrorMessage (guint32 code) return message; } -const static guchar -dbase64 [] = { - 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 62, 128, 128, 128, 63, - 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 128, 128, 128, 0, 128, 128, - 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 128, 128, 128, 128, 128, - 128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, - 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51 -}; - -static MonoArray * -base64_to_byte_array (gunichar2 *start, gint ilength, MonoBoolean allowWhitespaceOnly) -{ - gint ignored; - gint i; - gunichar2 c; - gunichar2 last, prev_last, prev2_last; - gint olength; - MonoArray *result; - guchar *res_ptr; - gint a [4], b [4]; - MonoException *exc; - - int havePadding = 0; - ignored = 0; - last = prev_last = 0, prev2_last = 0; - for (i = 0; i < ilength; i++) { - c = start [i]; - if (c >= sizeof (dbase64)) { - exc = mono_exception_from_name_msg (mono_get_corlib (), - "System", "FormatException", - "Invalid character found."); - mono_raise_exception (exc); - } else if (isspace (c)) { - ignored++; - } else if (havePadding && c != '=') { - exc = mono_exception_from_name_msg (mono_get_corlib (), - "System", "FormatException", - "Invalid character found."); - mono_raise_exception (exc); - } else { - if (c == '=') havePadding = 1; - prev2_last = prev_last; - prev_last = last; - last = c; - } - } - - olength = ilength - ignored; - - if (allowWhitespaceOnly && olength == 0) { - return mono_array_new (mono_domain_get (), mono_defaults.byte_class, 0); - } - - if ((olength & 3) != 0 || olength <= 0) { - exc = mono_exception_from_name_msg (mono_get_corlib (), "System", - "FormatException", "Invalid length."); - mono_raise_exception (exc); - } - - if (prev2_last == '=') { - exc = mono_exception_from_name_msg (mono_get_corlib (), "System", "FormatException", "Invalid format."); - mono_raise_exception (exc); - } - - olength = (olength * 3) / 4; - if (last == '=') - olength--; - - if (prev_last == '=') - olength--; - - result = mono_array_new (mono_domain_get (), mono_defaults.byte_class, olength); - res_ptr = mono_array_addr (result, guchar, 0); - for (i = 0; i < ilength; ) { - int k; - - for (k = 0; k < 4 && i < ilength;) { - c = start [i++]; - if (isspace (c)) - continue; - - a [k] = (guchar) c; - if (((b [k] = dbase64 [c]) & 0x80) != 0) { - exc = mono_exception_from_name_msg (mono_get_corlib (), - "System", "FormatException", - "Invalid character found."); - mono_raise_exception (exc); - } - k++; - } - - *res_ptr++ = (b [0] << 2) | (b [1] >> 4); - if (a [2] != '=') - *res_ptr++ = (b [1] << 4) | (b [2] >> 2); - if (a [3] != '=') - *res_ptr++ = (b [2] << 6) | b [3]; - - while (i < ilength && isspace (start [i])) - i++; - } - - return result; -} - -ICALL_EXPORT MonoArray * -InternalFromBase64String (MonoString *str, MonoBoolean allowWhitespaceOnly) +ICALL_EXPORT int +ves_icall_System_StackFrame_GetILOffsetFromFile (MonoString *path, guint32 method_token, guint32 method_index, int native_offset) { - MONO_ARCH_SAVE_REGS; + guint32 il_offset; + char *path_str = mono_string_to_utf8 (path); - return base64_to_byte_array (mono_string_chars (str), - mono_string_length (str), allowWhitespaceOnly); -} + if (!mono_seq_point_data_get_il_offset (path_str, method_token, method_index, native_offset, &il_offset)) + il_offset = -1; -ICALL_EXPORT MonoArray * -InternalFromBase64CharArray (MonoArray *input, gint offset, gint length) -{ - MONO_ARCH_SAVE_REGS; + g_free (path_str); - return base64_to_byte_array (mono_array_addr (input, gunichar2, offset), - length, FALSE); + return il_offset; } #ifndef DISABLE_ICALL_TABLES @@ -8165,7 +7477,7 @@ mono_lookup_internal_call (MonoMethod *method) g_warning ("cant resolve internal call to \"%s\" (tested without signature also)", mname); g_print ("\nYour mono runtime and class libraries are out of sync.\n"); g_print ("The out of sync library is: %s\n", method->klass->image->name); - g_print ("\nWhen you update one from svn you need to update, compile and install\nthe other too.\n"); + g_print ("\nWhen you update one from git you need to update, compile and install\nthe other too.\n"); g_print ("Do not report this as a bug unless you're sure you have updated correctly:\nyou probably have a broken mono install.\n"); g_print ("If you see other errors or faults after this message they are probably related\n"); g_print ("and you need to fix your mono install first.\n"); @@ -8416,8 +7728,12 @@ mono_register_jit_icall_wrapper (MonoJitICallInfo *info, gconstpointer wrapper) mono_icall_unlock (); } +/* + * If NO_RAISE is set, that means the icall is not calling mono_raise_exception () directly or indirectly. The JIT might be able to call these + * icalls without wrappers in some cases. + */ MonoJitICallInfo * -mono_register_jit_icall_full (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save, const char *c_symbol) +mono_register_jit_icall_full (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save, gboolean no_raise, const char *c_symbol) { MonoJitICallInfo *info; @@ -8442,6 +7758,7 @@ mono_register_jit_icall_full (gconstpointer func, const char *name, MonoMethodSi info->func = func; info->sig = sig; info->c_symbol = c_symbol; + info->no_raise = no_raise; if (is_save) { info->wrapper = func; @@ -8459,6 +7776,6 @@ mono_register_jit_icall_full (gconstpointer func, const char *name, MonoMethodSi MonoJitICallInfo * mono_register_jit_icall (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save) { - return mono_register_jit_icall_full (func, name, sig, is_save, NULL); + return mono_register_jit_icall_full (func, name, sig, is_save, FALSE, NULL); }