-#include <mono/metadata/object.h>
+#include <mono/metadata/object-internals.h>
#include <mono/metadata/verify.h>
#include <mono/metadata/opcodes.h>
#include <mono/metadata/tabledefs.h>
#include <mono/metadata/reflection.h>
#include <mono/metadata/debug-helpers.h>
#include <mono/metadata/mono-endian.h>
+#include <mono/metadata/metadata.h>
+#include <mono/metadata/metadata-internals.h>
+#include <mono/metadata/class-internals.h>
+#include <mono/metadata/tokentype.h>
#include <string.h>
#include <signal.h>
#include <ctype.h>
MonoTableInfo *t = &image->tables [MONO_TABLE_CONSTANT];
guint32 cols [MONO_CONSTANT_SIZE];
guint32 value, i;
- GHashTable *dups = g_hash_table_new (g_direct_hash, g_direct_equal);
+ GHashTable *dups = g_hash_table_new (NULL, NULL);
for (i = 0; i < t->rows; ++i) {
mono_metadata_decode_row (t, i, cols, MONO_CONSTANT_SIZE);
ADD_ERROR (list, g_strdup_printf ("Type 0x%x is invalid in Constant row %d", cols [MONO_CONSTANT_TYPE], i + 1));
}
if (level & MONO_VERIFY_ERROR) {
- value = cols [MONO_CONSTANT_PARENT] >> HASCONSTANT_BITS;
- switch (cols [MONO_CONSTANT_PARENT] & HASCONSTANT_MASK) {
- case HASCONSTANT_FIEDDEF:
+ value = cols [MONO_CONSTANT_PARENT] >> MONO_HASCONSTANT_BITS;
+ switch (cols [MONO_CONSTANT_PARENT] & MONO_HASCONSTANT_MASK) {
+ case MONO_HASCONSTANT_FIEDDEF:
if (value > image->tables [MONO_TABLE_FIELD].rows)
ADD_ERROR (list, g_strdup_printf ("Parent (field) is invalid in Constant row %d", i + 1));
break;
- case HASCONSTANT_PARAM:
+ case MONO_HASCONSTANT_PARAM:
if (value > image->tables [MONO_TABLE_PARAM].rows)
ADD_ERROR (list, g_strdup_printf ("Parent (param) is invalid in Constant row %d", i + 1));
break;
- case HASCONSTANT_PROPERTY:
+ case MONO_HASCONSTANT_PROPERTY:
if (value > image->tables [MONO_TABLE_PROPERTY].rows)
ADD_ERROR (list, g_strdup_printf ("Parent (property) is invalid in Constant row %d", i + 1));
break;
MonoTableInfo *t = &image->tables [MONO_TABLE_EVENTMAP];
guint32 cols [MONO_EVENT_MAP_SIZE];
guint32 i, last_event;
- GHashTable *dups = g_hash_table_new (g_direct_hash, g_direct_equal);
+ GHashTable *dups = g_hash_table_new (NULL, NULL);
last_event = 0;
}
if (level & MONO_VERIFY_ERROR && cols [MONO_EVENT_TYPE]) {
- value = cols [MONO_EVENT_TYPE] >> TYPEDEFORREF_BITS;
- switch (cols [MONO_EVENT_TYPE] & TYPEDEFORREF_MASK) {
- case TYPEDEFORREF_TYPEDEF:
+ value = cols [MONO_EVENT_TYPE] >> MONO_TYPEDEFORREF_BITS;
+ switch (cols [MONO_EVENT_TYPE] & MONO_TYPEDEFORREF_MASK) {
+ case MONO_TYPEDEFORREF_TYPEDEF:
if (!value || value > image->tables [MONO_TABLE_TYPEDEF].rows)
ADD_ERROR (list, g_strdup_printf ("Type invalid in Event row %d", i + 1));
break;
- case TYPEDEFORREF_TYPEREF:
+ case MONO_TYPEDEFORREF_TYPEREF:
if (!value || value > image->tables [MONO_TABLE_TYPEREF].rows)
ADD_ERROR (list, g_strdup_printf ("Type invalid in Event row %d", i + 1));
break;
- case TYPEDEFORREF_TYPESPEC:
+ case MONO_TYPEDEFORREF_TYPESPEC:
if (!value || value > image->tables [MONO_TABLE_TYPESPEC].rows)
ADD_ERROR (list, g_strdup_printf ("Type invalid in Event row %d", i + 1));
break;
case CEE_CONV_OVF_U2:
case CEE_CONV_OVF_I4:
case CEE_CONV_OVF_U4:
+ case CEE_CONV_OVF_I1_UN:
+ case CEE_CONV_OVF_U1_UN:
+ case CEE_CONV_OVF_I2_UN:
+ case CEE_CONV_OVF_U2_UN:
+ case CEE_CONV_OVF_I4_UN:
+ case CEE_CONV_OVF_U4_UN:
if (arg->stype == TYPE_INV || arg->stype >= TYPE_MP)
return arg->stype = TYPE_INV;
return arg->stype = TYPE_I4;
case CEE_CONV_U:
case CEE_CONV_OVF_I:
case CEE_CONV_OVF_U:
+ case CEE_CONV_OVF_I_UN:
+ case CEE_CONV_OVF_U_UN:
if (arg->stype == TYPE_INV || arg->stype == TYPE_VT)
return arg->stype = TYPE_INV;
return arg->stype = TYPE_PTR;
case CEE_CONV_U8:
case CEE_CONV_OVF_I8:
case CEE_CONV_OVF_U8:
+ case CEE_CONV_OVF_I8_UN:
+ case CEE_CONV_OVF_U8_UN:
return arg->stype = TYPE_I8;
case CEE_CONV_R4:
case CEE_CONV_R8:
{
MonoMethodHeader *header;
MonoMethodSignature *signature, *csig;
+ MonoGenericContext *generic_context = NULL;
MonoMethod *cmethod;
MonoClassField *field;
MonoClass *klass;
params = signature->params;
}
+ if (method->signature->is_inflated)
+ generic_context = ((MonoMethodInflated *) method)->context;
+
if (header->num_locals) {
local_state = g_new (char, header->num_locals);
memset (local_state, header->init_locals, header->num_locals);
#if 0
{
char *discode;
- discode = mono_disasm_code_one (NULL, method, ip);
+ discode = mono_disasm_code_one (NULL, method, ip, NULL);
discode [strlen (discode) - 1] = 0; /* no \n */
g_print ("%-29s (%d)\n", discode, cur_stack);
g_free (discode);
/*
* FIXME: we could just load the signature ...
*/
- cmethod = mono_get_method (image, token, NULL);
+ cmethod = mono_get_method_full (image, token, NULL, generic_context);
if (!cmethod)
ADD_INVALID (list, g_strdup_printf ("Method 0x%08x not found at 0x%04x", token, ip_offset));
- csig = cmethod->signature;
+ if (cmethod->signature->pinvoke) {
+ csig = cmethod->signature;
+ } else {
+ csig = mono_method_get_signature (cmethod, image, token);
+ }
+
CHECK_STACK_UNDERFLOW (csig->param_count + csig->hasthis);
cur_stack -= csig->param_count + csig->hasthis;
if (csig->ret->type != MONO_TYPE_VOID) {
CHECK_STACK_UNDERFLOW (1);
--cur_stack;
if (!can_store_type (stack + cur_stack, signature->ret))
- ADD_INVALID (list, g_strdup_printf ("Incompatible type in ret at 0x%04x", ip_offset));
+ ADD_INVALID (list, g_strdup_printf ("Incompatible type %s in ret at 0x%04x", arg_name [stack [cur_stack].stype], ip_offset));
}
if (cur_stack)
ADD_INVALID (list, g_strdup_printf ("Stack not empty (%d) after ret at 0x%04x", cur_stack, ip_offset));
if (in_any_block (header, ip_offset))
ADD_INVALID (list, g_strdup_printf ("ret cannot escape exception blocks at 0x%04x", ip_offset));
++ip;
+ start = 1;
break;
case CEE_BR_S:
target = ip + (signed char)ip [1] + 2;
CHECK_STACK_UNDERFLOW (1);
if (stack [cur_stack - 1].stype != TYPE_MP)
ADD_INVALID (list, g_strdup_printf ("Invalid argument to ldobj at 0x%04x", ip_offset));
- klass = mono_class_get (image, token);
+ klass = mono_class_get_full (image, token, generic_context);
if (!klass)
ADD_INVALID (list, g_strdup_printf ("Cannot load class from token 0x%08x at 0x%04x", token, ip_offset));
if (!klass->valuetype)
/*
* FIXME: we could just load the signature ...
*/
- cmethod = mono_get_method (image, token, NULL);
+ cmethod = mono_get_method_full (image, token, NULL, generic_context);
if (!cmethod)
ADD_INVALID (list, g_strdup_printf ("Constructor 0x%08x not found at 0x%04x", token, ip_offset));
csig = cmethod->signature;
token = read32 (ip + 1);
CHECK_STACK_UNDERFLOW (1);
if (stack [cur_stack - 1].stype != TYPE_OBJ)
- ADD_INVALID (list, g_strdup_printf ("Invalid argument to unbox at 0x%04x", ip_offset));
+ ADD_INVALID (list, g_strdup_printf ("Invalid argument %s to unbox at 0x%04x", arg_name [stack [cur_stack - 1].stype], ip_offset));
stack [cur_stack - 1].stype = TYPE_MP;
stack [cur_stack - 1].type = NULL;
ip += 5;
if (stack [cur_stack - 1].stype != TYPE_OBJ && stack [cur_stack - 1].stype != TYPE_MP)
ADD_INVALID (list, g_strdup_printf ("Invalid argument %s to ldfld at 0x%04x", arg_name [stack [cur_stack].stype], ip_offset));
token = read32 (ip + 1);
- field = mono_field_from_token (image, token, &klass);
+ field = mono_field_from_token (image, token, &klass, generic_context);
if (!field)
ADD_INVALID (list, g_strdup_printf ("Cannot load field from token 0x%08x at 0x%04x", token, ip_offset));
type_to_eval_stack_type (field->type, stack + cur_stack - 1, FALSE);
if (stack [cur_stack - 1].stype != TYPE_OBJ && stack [cur_stack - 1].stype != TYPE_MP)
ADD_INVALID (list, g_strdup_printf ("Invalid argument to ldflda at 0x%04x", ip_offset));
token = read32 (ip + 1);
- field = mono_field_from_token (image, token, &klass);
+ field = mono_field_from_token (image, token, &klass, generic_context);
if (!field)
ADD_INVALID (list, g_strdup_printf ("Cannot load field from token 0x%08x at 0x%04x", token, ip_offset));
type_to_eval_stack_type (field->type, stack + cur_stack - 1, TRUE);
if (stack [cur_stack].stype != TYPE_OBJ && stack [cur_stack].stype != TYPE_MP)
ADD_INVALID (list, g_strdup_printf ("Invalid argument to stfld at 0x%04x", ip_offset));
token = read32 (ip + 1);
- field = mono_field_from_token (image, token, &klass);
+ field = mono_field_from_token (image, token, &klass, generic_context);
if (!field)
ADD_INVALID (list, g_strdup_printf ("Cannot load field from token 0x%08x at 0x%04x", token, ip_offset));
/* can_store */
case CEE_LDSFLD:
CHECK_STACK_OVERFLOW ();
token = read32 (ip + 1);
- field = mono_field_from_token (image, token, &klass);
+ field = mono_field_from_token (image, token, &klass, generic_context);
if (!field)
ADD_INVALID (list, g_strdup_printf ("Cannot load field from token 0x%08x at 0x%04x", token, ip_offset));
type_to_eval_stack_type (field->type, stack + cur_stack, FALSE);
case CEE_LDSFLDA:
CHECK_STACK_OVERFLOW ();
token = read32 (ip + 1);
- field = mono_field_from_token (image, token, &klass);
+ field = mono_field_from_token (image, token, &klass, generic_context);
if (!field)
ADD_INVALID (list, g_strdup_printf ("Cannot load field from token 0x%08x at 0x%04x", token, ip_offset));
type_to_eval_stack_type (field->type, stack + cur_stack, TRUE);
CHECK_STACK_UNDERFLOW (1);
--cur_stack;
token = read32 (ip + 1);
- field = mono_field_from_token (image, token, &klass);
+ field = mono_field_from_token (image, token, &klass, generic_context);
if (!field)
ADD_INVALID (list, g_strdup_printf ("Cannot load field from token 0x%08x at 0x%04x", token, ip_offset));
/* can store */
CHECK_STACK_UNDERFLOW (1);
token = read32 (ip + 1);
if (stack [cur_stack - 1].stype == TYPE_OBJ)
- ADD_INVALID (list, g_strdup_printf ("Invalid argument to box at 0x%04x", ip_offset));
+ ADD_INVALID (list, g_strdup_printf ("Invalid argument %s to box at 0x%04x", arg_name [stack [cur_stack - 1].stype], ip_offset));
stack [cur_stack - 1].stype = TYPE_OBJ;
ip += 5;
break;
cur_stack -= 3;
++ip;
break;
- case CEE_UNUSED2:
- case CEE_UNUSED3:
- case CEE_UNUSED4:
+ case CEE_LDELEM:
+ case CEE_STELEM:
+ case CEE_UNBOX_ANY:
case CEE_UNUSED5:
case CEE_UNUSED6:
case CEE_UNUSED7:
case CEE_CLT_UN:
CHECK_STACK_UNDERFLOW (2);
--cur_stack;
+ if (type_from_op (256 + *ip, stack + cur_stack - 1) == TYPE_INV)
+ ADD_INVALID (list, g_strdup_printf ("Invalid arguments to opcode 0xFE 0x%02x at 0x%04x", *ip, ip_offset));
++ip;
break;
case CEE_LDFTN:
break;
case CEE_LDLOC:
case CEE_LDLOCA:
- if (read16 (ip + 1) >= header->num_locals)
- ADD_INVALID (list, g_strdup_printf ("Method doesn't have local var %d at 0x%04x", read16 (ip + 1), ip_offset));
+ n = read16 (ip + 1);
+ if (n >= header->num_locals)
+ ADD_INVALID (list, g_strdup_printf ("Method doesn't have local var %d at 0x%04x", n, ip_offset));
/* no need to check if the var is initialized if the address is taken */
- if (0 && *ip == CEE_LDLOC && !local_state [read16 (ip + 1)])
- ADD_INVALID (list, g_strdup_printf ("Local var %d is initialized at 0x%04x", read16 (ip + 1), ip_offset));
+ if (0 && *ip == CEE_LDLOC && !local_state [n])
+ ADD_INVALID (list, g_strdup_printf ("Local var %d is initialized at 0x%04x", n, ip_offset));
CHECK_STACK_OVERFLOW ();
+ type_to_eval_stack_type (header->locals [n], stack + cur_stack, *ip == CEE_LDLOCA);
++cur_stack;
ip += 3;
break;
case CEE_STLOC:
- if (read16 (ip + 1) >= header->num_locals)
- ADD_INVALID (list, g_strdup_printf ("Method doesn't have local var %d at 0x%04x", read16 (ip + 1), ip_offset));
- local_state [read16 (ip + 1)] = 1;
+ n = read16 (ip + 1);
+ if (n >= header->num_locals)
+ ADD_INVALID (list, g_strdup_printf ("Method doesn't have local var %d at 0x%04x", n, ip_offset));
+ local_state [n] = 1;
CHECK_STACK_UNDERFLOW (1);
--cur_stack;
+ if (!can_store_type (stack + cur_stack, header->locals [n]))
+ ADD_INVALID (list, g_strdup_printf ("Incompatible type %s in store at 0x%04x", arg_name [stack [cur_stack].stype], ip_offset));
ip += 3;
break;
case CEE_LOCALLOC:
ip += 5;
--cur_stack;
break;
- case CEE_UNUSED68:
- ++ip;
+ case CEE_CONSTRAINED_:
+ token = read32 (ip + 1);
+ ip += 5;
break;
case CEE_CPBLK:
CHECK_STACK_UNDERFLOW (3);
CHECK_STACK_UNDERFLOW (3);
ip++;
break;
- case CEE_UNUSED69:
- ++ip;
+ case CEE_NO_:
+ ip += 2;
break;
case CEE_RETHROW:
++ip;
CHECK_STACK_UNDERFLOW (1);
++ip;
break;
- case CEE_UNUSED52:
case CEE_UNUSED53:
case CEE_UNUSED54:
case CEE_UNUSED55:
}
}
/*
- * FIXME: if ip != end we overflowed: mark as error.
+ * if ip != end we overflowed: mark as error.
*/
+ if (ip != end || !start) {
+ ADD_INVALID (list, g_strdup_printf ("Run ahead of method code at 0x%04x", ip_offset));
+ }
invalid_cil:
g_free (local_state);
{"entry_point", G_STRUCT_OFFSET (MonoReflectionAssemblyBuilder, entry_point)},
{"modules", G_STRUCT_OFFSET (MonoReflectionAssemblyBuilder, modules)},
{"name", G_STRUCT_OFFSET (MonoReflectionAssemblyBuilder, name)},
+ {"resources", G_STRUCT_OFFSET (MonoReflectionAssemblyBuilder, resources)},
+ {"version", G_STRUCT_OFFSET (MonoReflectionAssemblyBuilder, version)},
+ {"culture", G_STRUCT_OFFSET (MonoReflectionAssemblyBuilder, culture)},
{NULL, 0}
};
static const FieldDesc
ilgenerator_fields[] = {
{"code", G_STRUCT_OFFSET (MonoReflectionILGen, code)},
- {"mbuilder", G_STRUCT_OFFSET (MonoReflectionILGen, mbuilder)},
{"code_len", G_STRUCT_OFFSET (MonoReflectionILGen, code_len)},
{"max_stack", G_STRUCT_OFFSET (MonoReflectionILGen, max_stack)},
{"cur_stack", G_STRUCT_OFFSET (MonoReflectionILGen, cur_stack)},
{NULL, 0}
};
-static const FieldDesc
-monofieldinfo_fields[] = {
- {"parent", G_STRUCT_OFFSET (MonoFieldInfo, parent)},
- {"type", G_STRUCT_OFFSET (MonoFieldInfo, type)},
- {"name", G_STRUCT_OFFSET (MonoFieldInfo, name)},
- {"attrs", G_STRUCT_OFFSET (MonoFieldInfo, attrs)},
- {NULL, 0}
-};
-
static const FieldDesc
monomethod_fields[] = {
{"mhandle", G_STRUCT_OFFSET (MonoReflectionMethod, method)},
{"MonoField", monofield_fields},
{"MonoMethodInfo", monomethodinfo_fields},
{"MonoPropertyInfo", monopropertyinfo_fields},
- {"MonoFieldInfo", monofieldinfo_fields},
{"MonoMethod", monomethod_fields},
{"MonoCMethod", monocmethod_fields},
{"ParameterInfo", pinfo_fields},
{"sync_completed", G_STRUCT_OFFSET (MonoAsyncResult, sync_completed)},
{"completed", G_STRUCT_OFFSET (MonoAsyncResult, completed)},
{"endinvoke_called", G_STRUCT_OFFSET (MonoAsyncResult, endinvoke_called)},
+ {"async_callback", G_STRUCT_OFFSET (MonoAsyncResult, async_callback)},
{NULL, 0}
};
static FieldDesc
transparent_proxy_fields[] = {
{"_rp", G_STRUCT_OFFSET (MonoTransparentProxy, rp)},
- {"_class", G_STRUCT_OFFSET (MonoTransparentProxy, klass)},
+ {"_class", G_STRUCT_OFFSET (MonoTransparentProxy, remote_class)},
{NULL, 0}
};
{NULL, 0}
};
+static FieldDesc
+thread_fields[] = {
+ {"system_thread_handle", G_STRUCT_OFFSET (MonoThread, handle)},
+ {"current_culture", G_STRUCT_OFFSET (MonoThread, culture_info)},
+ {"threadpool_thread", G_STRUCT_OFFSET (MonoThread, threadpool_thread)},
+ {"state", G_STRUCT_OFFSET (MonoThread, state)},
+ {"abort_exc", G_STRUCT_OFFSET (MonoThread, abort_exc)},
+ {"abort_state", G_STRUCT_OFFSET (MonoThread, abort_state)},
+ {"thread_id", G_STRUCT_OFFSET (MonoThread, tid)},
+ {NULL, 0}
+};
+
static const ClassDesc
threading_classes_to_check [] = {
+ {"Thread", thread_fields},
{"WaitHandle", wait_handle_fields},
{NULL, NULL}
};
+static const FieldDesc
+cinfo_fields[] = {
+ {"datetime_format", G_STRUCT_OFFSET (MonoCultureInfo, datetime_format)},
+ {"number_format", G_STRUCT_OFFSET (MonoCultureInfo, number_format)},
+ {"textinfo", G_STRUCT_OFFSET (MonoCultureInfo, textinfo)},
+ {"name", G_STRUCT_OFFSET (MonoCultureInfo, name)},
+ {"displayname", G_STRUCT_OFFSET (MonoCultureInfo, displayname)},
+ {"englishname", G_STRUCT_OFFSET (MonoCultureInfo, englishname)},
+ {"nativename", G_STRUCT_OFFSET (MonoCultureInfo, nativename)},
+ {"iso3lang", G_STRUCT_OFFSET (MonoCultureInfo, iso3lang)},
+ {"iso2lang", G_STRUCT_OFFSET (MonoCultureInfo, iso2lang)},
+ {"icu_name", G_STRUCT_OFFSET (MonoCultureInfo, icu_name)},
+ {"win3lang", G_STRUCT_OFFSET (MonoCultureInfo, win3lang)},
+ {"compareinfo", G_STRUCT_OFFSET (MonoCultureInfo, compareinfo)},
+ {NULL, 0}
+};
+
+static const FieldDesc
+dtfinfo_fields[] = {
+ {"_AMDesignator", G_STRUCT_OFFSET (MonoDateTimeFormatInfo, AMDesignator)},
+ {"_PMDesignator", G_STRUCT_OFFSET (MonoDateTimeFormatInfo, PMDesignator)},
+ {"_DayNames", G_STRUCT_OFFSET (MonoDateTimeFormatInfo, DayNames)},
+ {"_MonthNames", G_STRUCT_OFFSET (MonoDateTimeFormatInfo, MonthNames)},
+ {NULL, 0}
+};
+
+static const FieldDesc
+nfinfo_fields[] = {
+ {"decimalFormats", G_STRUCT_OFFSET (MonoNumberFormatInfo, decimalFormats)},
+ {"currencySymbol", G_STRUCT_OFFSET (MonoNumberFormatInfo, currencySymbol)},
+ {"percentSymbol", G_STRUCT_OFFSET (MonoNumberFormatInfo, percentSymbol)},
+ {"positiveSign", G_STRUCT_OFFSET (MonoNumberFormatInfo, positiveSign)},
+ {NULL, 0}
+};
+
+static const FieldDesc
+compinfo_fields[] = {
+ {"lcid", G_STRUCT_OFFSET (MonoCompareInfo, lcid)},
+ {"ICU_collator", G_STRUCT_OFFSET (MonoCompareInfo, ICU_collator)},
+ {NULL, 0}
+};
+
+static const FieldDesc
+sortkey_fields[] = {
+ {"str", G_STRUCT_OFFSET (MonoSortKey, str)},
+ {"options", G_STRUCT_OFFSET (MonoSortKey, options)},
+ {"key", G_STRUCT_OFFSET (MonoSortKey, key)},
+ {"lcid", G_STRUCT_OFFSET (MonoSortKey, lcid)},
+ {NULL, 0}
+};
+
+static const ClassDesc
+globalization_classes_to_check [] = {
+ {"CultureInfo", cinfo_fields},
+ {"DateTimeFormatInfo", dtfinfo_fields},
+ {"NumberFormatInfo", nfinfo_fields},
+ {"CompareInfo", compinfo_fields},
+ {"SortKey", sortkey_fields},
+ {NULL, NULL}
+};
+
typedef struct {
const char *name;
const ClassDesc *types;
{"System.Threading", threading_classes_to_check},
{"System.Diagnostics", system_diagnostics_classes_to_check},
{"System", system_classes_to_check},
+ {"System.Globalization", globalization_classes_to_check},
{NULL, NULL}
};
const ClassDesc *cdesc;
const NameSpaceDesc *ndesc;
gint struct_offset;
+ GString *result = NULL;
for (ndesc = namespaces_to_check; ndesc->name; ++ndesc) {
for (cdesc = ndesc->types; cdesc->name; ++cdesc) {
klass = mono_class_from_name (corlib, ndesc->name, cdesc->name);
- if (!klass)
- return g_strdup_printf ("Cannot find class %s", cdesc->name);
+ if (!klass) {
+ if (!result)
+ result = g_string_new ("");
+ g_string_append_printf (result, "Cannot find class %s\n", cdesc->name);
+ continue;
+ }
mono_class_init (klass);
/*
* FIXME: we should also check the size of valuetypes, or
* we're going to have trouble when we access them in arrays.
*/
if (klass->valuetype)
- struct_offset = 8;
+ struct_offset = sizeof (MonoObject);
else
struct_offset = 0;
for (fdesc = cdesc->fields; fdesc->name; ++fdesc) {
field = mono_class_get_field_from_name (klass, fdesc->name);
- if (!field || (field->offset != (fdesc->offset + struct_offset)))
- return g_strdup_printf ("field `%s' mismatch in class %s (%ld != %ld)", fdesc->name, cdesc->name, (long) fdesc->offset, (long) (field?field->offset:-1));
+ if (!field || (field->offset != (fdesc->offset + struct_offset))) {
+ if (!result)
+ result = g_string_new ("");
+ g_string_append_printf (result, "field `%s' mismatch in class %s (%ld + %ld != %ld)\n", fdesc->name, cdesc->name, (long) fdesc->offset, (long)struct_offset, (long) (field?field->offset:-1));
+ }
}
}
}
+ if (result)
+ return g_string_free (result, FALSE);
return NULL;
}
return check_corlib (mono_defaults.corlib);
}
+
projects / mono.git / blobdiff