*/
#include <config.h>
-#ifdef HAVE_ALLOCA_H
-#include <alloca.h>
-#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
n = MAX (n, meta->tables [MONO_TABLE_METHOD].rows);
n = MAX (n, meta->tables [MONO_TABLE_MODULEREF].rows);
n = MAX (n, meta->tables [MONO_TABLE_TYPESPEC].rows);
- n = MAX (n, meta->tables [MONO_TABLE_MEMBERREF].rows);
/* 3 bits to encode */
field_size = rtsize (n, 16 - 3);
const char *
mono_metadata_string_heap (MonoImage *meta, guint32 index)
{
+ g_assert (index < meta->heap_strings.size);
g_return_val_if_fail (index < meta->heap_strings.size, "");
return meta->heap_strings.data + index;
}
const char *
mono_metadata_user_string (MonoImage *meta, guint32 index)
{
+ g_assert (index < meta->heap_us.size);
g_return_val_if_fail (index < meta->heap_us.size, "");
return meta->heap_us.data + index;
}
const char *
mono_metadata_blob_heap (MonoImage *meta, guint32 index)
{
+ g_assert (index < meta->heap_blob.size);
g_return_val_if_fail (index < meta->heap_blob.size, "");/*FIXME shouldn't we return NULL and check for index == 0?*/
return meta->heap_blob.data + index;
}
/* The gclass itself is allocated from the image set mempool */
if (gclass->is_dynamic)
mono_reflection_free_dynamic_generic_class (gclass);
+ if (gclass->cached_class && gclass->cached_class->interface_id)
+ mono_unload_interface_id (gclass->cached_class);
}
static void
break;
is_open = (i < type_argc);
- ginst = alloca (size);
-#ifndef MONO_SMALL_CONFIG
- ginst->id = 0;
-#endif
+ ginst = g_alloca (size);
+ memset (ginst, 0, sizeof (MonoGenericInst));
ginst->is_open = is_open;
ginst->type_argc = type_argc;
memcpy (ginst->type_argv, type_argv, type_argc * sizeof (MonoType *));
return NULL;
}
+static gboolean
+compare_type_literals (int class_type, int type_type)
+{
+ /* byval_arg.type can be zero if we're decoding a type that references a class been loading.
+ * See mcs/test/gtest-440. and #650936.
+ * FIXME This better be moved to the metadata verifier as it can catch more cases.
+ */
+ if (!class_type)
+ return TRUE;
+ /* NET 1.1 assemblies might encode string and object in a denormalized way.
+ * See #675464.
+ */
+ if (type_type == MONO_TYPE_CLASS && (class_type == MONO_TYPE_STRING || class_type == MONO_TYPE_OBJECT))
+ return TRUE;
+ return class_type == type_type;
+}
+
/*
* do_mono_metadata_parse_type:
* @type: MonoType to be filled in with the return value
type->data.klass = class;
if (!class)
return FALSE;
- /* byval_arg.type can be zero if we're decoding a type that references a class been loading.
- * See mcs/test/gtest-440. and #650936.
- * FIXME This better be moved to the metadata verifier as it can catch more cases.
- */
- if (class->byval_arg.type && class->byval_arg.type != type->type)
+ if (!compare_type_literals (class->byval_arg.type, type->type))
return FALSE;
break;
}
*
* Returns: the 1-based index into the TypeDef table of the type
* where the type described by @index is nested.
- * Retruns 0 if @index describes a non-nested type.
+ * Returns 0 if @index describes a non-nested type.
*/
guint32
mono_metadata_nested_in_typedef (MonoImage *meta, guint32 index)
}
#endif
-#ifndef __GNUC__
-/*#define __alignof__(a) sizeof(a)*/
-#define __alignof__(type) G_STRUCT_OFFSET(struct { char c; type x; }, x)
-#endif
+#define abi__alignof__(type) G_STRUCT_OFFSET(struct { char c; type x; }, x)
/*
* mono_type_size:
return 0;
}
if (t->byref) {
- *align = __alignof__(gpointer);
+ *align = abi__alignof__(gpointer);
return sizeof (gpointer);
}
*align = 1;
return 0;
case MONO_TYPE_BOOLEAN:
- *align = __alignof__(gint8);
+ *align = abi__alignof__(gint8);
return 1;
case MONO_TYPE_I1:
case MONO_TYPE_U1:
- *align = __alignof__(gint8);
+ *align = abi__alignof__(gint8);
return 1;
case MONO_TYPE_CHAR:
case MONO_TYPE_I2:
case MONO_TYPE_U2:
- *align = __alignof__(gint16);
+ *align = abi__alignof__(gint16);
return 2;
case MONO_TYPE_I4:
case MONO_TYPE_U4:
- *align = __alignof__(gint32);
+ *align = abi__alignof__(gint32);
return 4;
case MONO_TYPE_R4:
- *align = __alignof__(float);
+ *align = abi__alignof__(float);
return 4;
case MONO_TYPE_I8:
case MONO_TYPE_U8:
- *align = __alignof__(gint64);
+ *align = abi__alignof__(gint64);
return 8;
case MONO_TYPE_R8:
- *align = __alignof__(double);
+ *align = abi__alignof__(double);
return 8;
case MONO_TYPE_I:
case MONO_TYPE_U:
- *align = __alignof__(gpointer);
+ *align = abi__alignof__(gpointer);
return sizeof (gpointer);
case MONO_TYPE_STRING:
- *align = __alignof__(gpointer);
+ *align = abi__alignof__(gpointer);
return sizeof (gpointer);
case MONO_TYPE_OBJECT:
- *align = __alignof__(gpointer);
+ *align = abi__alignof__(gpointer);
return sizeof (gpointer);
case MONO_TYPE_VALUETYPE: {
if (t->data.klass->enumtype)
case MONO_TYPE_PTR:
case MONO_TYPE_FNPTR:
case MONO_TYPE_ARRAY:
- *align = __alignof__(gpointer);
+ *align = abi__alignof__(gpointer);
return sizeof (gpointer);
case MONO_TYPE_TYPEDBYREF:
return mono_class_value_size (mono_defaults.typed_reference_class, (guint32*)align);
else
return mono_class_value_size (mono_class_from_mono_type (t), (guint32*)align);
} else {
- *align = __alignof__(gpointer);
+ *align = abi__alignof__(gpointer);
return sizeof (gpointer);
}
}
case MONO_TYPE_VAR:
case MONO_TYPE_MVAR:
/* FIXME: Martin, this is wrong. */
- *align = __alignof__(gpointer);
+ *align = abi__alignof__(gpointer);
return sizeof (gpointer);
default:
g_error ("mono_type_size: type 0x%02x unknown", t->type);
int tmp;
#if SIZEOF_VOID_P == SIZEOF_REGISTER
int stack_slot_size = sizeof (gpointer);
- int stack_slot_align = __alignof__ (gpointer);
+ int stack_slot_align = abi__alignof__ (gpointer);
#elif SIZEOF_VOID_P < SIZEOF_REGISTER
int stack_slot_size = SIZEOF_REGISTER;
int stack_slot_align = SIZEOF_REGISTER;
*align = stack_slot_align;
return stack_slot_size * 3;
case MONO_TYPE_R4:
- *align = __alignof__(float);
+ *align = abi__alignof__(float);
return sizeof (float);
case MONO_TYPE_I8:
case MONO_TYPE_U8:
- *align = __alignof__(gint64);
+ *align = abi__alignof__(gint64);
return sizeof (gint64);
case MONO_TYPE_R8:
- *align = __alignof__(double);
+ *align = abi__alignof__(double);
return sizeof (double);
case MONO_TYPE_VALUETYPE: {
guint32 size;
return TRUE;
if (mono_generic_param_num (p1) != mono_generic_param_num (p2))
return FALSE;
+ if (p1->serial != p2->serial)
+ return FALSE;
/*
* We have to compare the image as well because if we didn't,
if (signature_only &&
(c1->byval_arg.type == MONO_TYPE_SZARRAY) && (c2->byval_arg.type == MONO_TYPE_SZARRAY))
return mono_metadata_class_equal (c1->byval_arg.data.klass, c2->byval_arg.data.klass, signature_only);
+ if (signature_only &&
+ (c1->byval_arg.type == MONO_TYPE_ARRAY) && (c2->byval_arg.type == MONO_TYPE_ARRAY))
+ return do_mono_metadata_type_equal (&c1->byval_arg, &c2->byval_arg, signature_only);
return FALSE;
}
projects / mono.git / blobdiff