| blob | 58afc5b3e6e07ea5e0c8ae7aad9a967d9a79d918 |
1 /*
2 * class.c: Class management for the Mono runtime
3 *
4 * Author:
5 * Miguel de Icaza (miguel@ximian.com)
6 *
7 * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
8 * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
9 */
10 #include <config.h>
11 #ifdef HAVE_ALLOCA_H
12 #include <alloca.h>
13 #endif
14 #include <glib.h>
15 #include <stdio.h>
16 #include <string.h>
17 #include <stdlib.h>
18 #include <signal.h>
19 #if !PLATFORM_WIN32
20 #include <mono/io-layer/atomic.h>
21 #endif
22 #include <mono/metadata/image.h>
23 #include <mono/metadata/assembly.h>
24 #include <mono/metadata/metadata.h>
25 #include <mono/metadata/metadata-internals.h>
26 #include <mono/metadata/profiler-private.h>
27 #include <mono/metadata/tabledefs.h>
28 #include <mono/metadata/tokentype.h>
29 #include <mono/metadata/class-internals.h>
30 #include <mono/metadata/object.h>
31 #include <mono/metadata/appdomain.h>
32 #include <mono/metadata/mono-endian.h>
33 #include <mono/metadata/debug-helpers.h>
34 #include <mono/metadata/reflection.h>
35 #include <mono/metadata/exception.h>
36 #include <mono/metadata/security-manager.h>
37 #include <mono/metadata/security-core-clr.h>
38 #include <mono/metadata/attrdefs.h>
39 #include <mono/metadata/gc-internal.h>
40 #include <mono/metadata/verify-internals.h>
41 #include <mono/metadata/mono-debug.h>
42 #include <mono/utils/mono-counters.h>
44 MonoStats mono_stats;
48 /*
49 * Controls whenever mono_class_init () constructs a generic vtable. This is TRUE by
50 * default to avoid breaking embedding apps, but set to FALSE by the runtime executable
51 * startup code.
52 */
55 /* Statistics */
59 /* Function supplied by the runtime to find classes by name using information from the AOT file */
65 static MonoMethod* find_method_in_metadata (MonoClass *klass, const char *name, int param_count, int flags);
67 static void setup_generic_array_ifaces (MonoClass *class, MonoClass *iface, MonoMethod **methods, int pos);
74 /*
75 * mono_class_from_typeref:
76 * @image: a MonoImage
77 * @type_token: a TypeRef token
78 *
79 * Creates the MonoClass* structure representing the type defined by
80 * the typeref token valid inside @image.
81 * Returns: the MonoClass* representing the typeref token, NULL ifcould
82 * not be loaded.
83 */
84 MonoClass *
86 {
89 guint32 idx;
104 /* a typedef in disguise */
120 }
126 /* Micro-optimization: don't scan the metadata tables if enclosing is already inited */
131 }
133 /* Don't call mono_class_init as we might've been called by it recursively */
136 guint32 class_nested = mono_metadata_decode_row_col (&enclosing->image->tables [MONO_TABLE_NESTEDCLASS], i - 1, MONO_NESTED_CLASS_NESTED);
137 guint32 string_offset = mono_metadata_decode_row_col (&enclosing->image->tables [MONO_TABLE_TYPEDEF], class_nested - 1, MONO_TYPEDEF_NAME);
144 }
145 }
146 g_warning ("TypeRef ResolutionScope not yet handled (%d) for %s.%s in image %s", idx, nspace, name, image->name);
148 }
151 }
157 /* If the assembly did not load, register this as a type load exception */
159 MonoAssemblyName aname;
168 }
171 }
176 {
180 }
182 /* Copy everything mono_metadata_free_array free. */
183 MonoArrayType *
185 {
198 }
200 }
202 /* Copy everything mono_metadata_free_method_signature free. */
203 MonoMethodSignature*
205 {
215 }
217 static void
219 {
229 }
233 {
236 }
238 static void
240 MonoTypeNameFormat format)
241 {
247 MonoTypeNameFormat nested_format;
266 }
268 MonoTypeNameFormat nested_format;
282 }
284 MonoTypeNameFormat nested_format;
298 }
314 else
319 }
332 MonoTypeNameFormat nested_format;
340 else
354 }
357 else
366 else
372 }
375 else
377 }
385 }
386 }
388 /**
389 * mono_type_get_name:
390 * @type: a type
391 * @format: the format for the return string.
392 *
393 *
394 * Returns: the string representation in a number of formats:
395 *
396 * if format is MONO_TYPE_NAME_FORMAT_REFLECTION, the return string is
397 * returned in the formatrequired by System.Reflection, this is the
398 * inverse of mono_reflection_parse_type ().
399 *
400 * if format is MONO_TYPE_NAME_FORMAT_IL, it returns a syntax that can
401 * be used by the IL assembler.
402 *
403 * if format is MONO_TYPE_NAME_FORMAT_FULL_NAME
404 *
405 * if format is MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED
406 */
409 {
417 }
419 /**
420 * mono_type_get_full_name:
421 * @class: a class
422 *
423 * Returns: the string representation for type as required by System.Reflection.
424 * The inverse of mono_reflection_parse_type ().
425 */
428 {
430 }
432 /**
433 * mono_type_get_name:
434 * @type: a type
435 *
436 * Returns: the string representation for type as it would be represented in IL code.
437 */
440 {
442 }
444 /*
445 * mono_type_get_underlying_type:
446 * @type: a type
447 *
448 * Returns: the MonoType for the underlying integer type if @type
449 * is an enum and byref is false, otherwise the type itself.
450 */
451 MonoType*
453 {
456 if (type->type == MONO_TYPE_GENERICINST && type->data.generic_class->container_class->enumtype && !type->byref)
459 }
461 /*
462 * mono_class_is_open_constructed_type:
463 * @type: a type
464 *
465 * Returns TRUE if type represents a generics open constructed type
466 * (not all the type parameters required for the instantiation have
467 * been provided).
468 */
469 gboolean
471 {
486 }
487 }
491 {
500 g_error ("MVAR %d (%s) cannot be expanded in this context with %d instantiations", num, type->data.generic_param->name, inst->type_argc);
502 /*
503 * Note that the VAR/MVAR cases are different from the rest. The other cases duplicate @type,
504 * while the VAR/MVAR duplicates a type from the context. So, we need to ensure that the
505 * ->byref and ->attrs from @type are propagated to the returned type.
506 */
511 }
519 g_error ("VAR %d (%s) cannot be expanded in this context with %d instantiations", num, type->data.generic_param->name, inst->type_argc);
524 }
534 }
545 }
555 gclass = mono_metadata_lookup_generic_class (gclass->container_class, inst, gclass->is_dynamic);
563 }
575 /* We can't use context->class_inst directly, since it can have more elements */
586 }
589 }
591 }
593 MonoGenericContext *
595 {
597 }
599 MonoGenericContext *
601 {
603 }
605 /*
606 * mono_class_get_generic_container:
607 *
608 * Return the generic container of KLASS which should be a generic type definition.
609 */
610 MonoGenericContainer*
612 {
616 }
618 /*
619 * mono_class_get_generic_class:
620 *
621 * Return the MonoGenericClass of KLASS, which should be a generic instance.
622 */
623 MonoGenericClass*
625 {
629 }
631 /*
632 * mono_class_inflate_generic_type_with_mempool:
633 * @mempool: a mempool
634 * @type: a type
635 * @context: a generics context
636 *
637 * The same as mono_class_inflate_generic_type, but allocates the MonoType
638 * from mempool if it is non-NULL. If it is NULL, the MonoType is
639 * allocated on the heap and is owned by the caller.
640 * The returned type can potentially be the same as TYPE, so it should not be
641 * modified by the caller, and it should be freed using mono_metadata_free_type ().
642 */
643 MonoType*
644 mono_class_inflate_generic_type_with_mempool (MonoImage *image, MonoType *type, MonoGenericContext *context)
645 {
658 }
659 }
663 }
665 /*
666 * mono_class_inflate_generic_type:
667 * @type: a type
668 * @context: a generics context
669 *
670 * If @type is a generic type and @context is not NULL, instantiate it using the
671 * generics context @context.
672 *
673 * Returns: the instantiated type or a copy of @type. The returned MonoType is allocated
674 * on the heap and is owned by the caller.
675 */
676 MonoType*
678 {
680 }
682 /*
683 * mono_class_inflate_generic_type_no_copy:
684 *
685 * Same as inflate_generic_type_with_mempool, but return TYPE if no inflation
686 * was done.
687 */
689 mono_class_inflate_generic_type_no_copy (MonoImage *image, MonoType *type, MonoGenericContext *context)
690 {
701 }
703 /*
704 * mono_class_inflate_generic_class:
705 *
706 * Inflate the class GKLASS with CONTEXT.
707 */
708 MonoClass*
710 {
720 }
722 static MonoGenericContext
724 {
727 MonoGenericContext res;
739 }
741 /*
742 * mono_class_inflate_generic_method:
743 * @method: a generic method
744 * @context: a generics context
745 *
746 * Instantiate the generic method @method using the generics context @context.
747 *
748 * Returns: the new instantiated method
749 */
750 MonoMethod *
752 {
754 }
756 /**
757 * mono_class_inflate_generic_method:
758 *
759 * Instantiate method @method with the generic context @context.
760 * BEWARE: All non-trivial fields are invalid, including klass, signature, and header.
761 * Use mono_method_signature () and mono_method_get_header () to get the correct values.
762 */
763 MonoMethod*
764 mono_class_inflate_generic_method_full (MonoMethod *method, MonoClass *klass_hint, MonoGenericContext *context)
765 {
769 MonoGenericContext tmp_context;
772 /* The `method' has already been instantiated before => we need to peel out the instantiation and create a new context */
784 }
789 /*
790 * The reason for this hack is to fix the behavior of inflating generic methods that come from a MethodBuilder.
791 * What happens is that instantiating a generic MethodBuilder with its own arguments should create a diferent object.
792 * This is opposite to the way non-SRE MethodInfos behave.
793 *
794 * This happens, for example, when we want to emit a recursive generic method. Given the following C# code:
795 *
796 * void Example<T> () {
797 * Example<T> ();
798 * }
799 *
800 * In Example, the method token must be encoded as: "void Example<!!0>()"
801 *
802 * The reference to the first generic argument, "!!0", must be explicit otherwise it won't be inflated
803 * properly. To get that we need to inflate the MethodBuilder with its own arguments.
804 *
805 * On the other hand, inflating a non-SRE generic method with its own arguments should
806 * return itself. For example:
807 *
808 * MethodInfo m = ... //m is a generic method definition
809 * MethodInfo res = m.MakeGenericMethod (m.GetGenericArguments ());
810 * res == m
811 *
812 * To allow such scenarios we must allow inflation of MethodBuilder to happen in a diferent way than
813 * what happens with regular methods.
814 *
815 * There is one last touch to this madness, once a TypeBuilder is finished, IOW CreateType() is called,
816 * everything should behave like a regular type or method.
817 *
818 */
820 method->klass->image->dynamic && !method->klass->wastypebuilder && /* that is a MethodBuilder from an unfinished TypeBuilder */
821 context->method_inst == mono_method_get_generic_container (method)->context.method_inst; /* and it's been instantiated with its own arguments. */
837 }
845 }
857 }
866 /* Set the generic_container of the result to the generic_container of method */
872 }
873 }
888 }
893 }
895 /**
896 * mono_get_inflated_method:
897 *
898 * Obsolete. We keep it around since it's mentioned in the public API.
899 */
900 MonoMethod*
902 {
904 }
906 /*
907 * mono_method_get_context_general:
908 * @method: a method
909 * @uninflated: handle uninflated methods?
910 *
911 * Returns the generic context of a method or NULL if it doesn't have
912 * one. For an inflated method that's the context stored in the
913 * method. Otherwise it's in the method's generic container or in the
914 * generic container of the method's class.
915 */
916 MonoGenericContext*
918 {
922 }
930 }
932 /*
933 * mono_method_get_context:
934 * @method: a method
935 *
936 * Returns the generic context for method if it's inflated, otherwise
937 * NULL.
938 */
939 MonoGenericContext*
941 {
943 }
945 /*
946 * mono_method_get_generic_container:
947 *
948 * Returns the generic container of METHOD, which should be a generic method definition.
949 * Returns NULL if METHOD is not a generic method definition.
950 * LOCKING: Acquires the loader lock.
951 */
952 MonoGenericContainer*
954 {
960 container = mono_image_property_lookup (method->klass->image, method, MONO_METHOD_PROP_GENERIC_CONTAINER);
964 }
966 /*
967 * mono_method_set_generic_container:
968 *
969 * Sets the generic container of METHOD to CONTAINER.
970 * LOCKING: Acquires the loader lock.
971 */
972 void
974 {
977 mono_image_property_insert (method->klass->image, method, MONO_METHOD_PROP_GENERIC_CONTAINER, container);
978 }
980 /**
981 * mono_class_find_enum_basetype:
982 * @class: The enum class
983 *
984 * Determine the basetype of an enum by iterating through its fields. We do this
985 * in a separate function since it is cheaper than calling mono_class_setup_fields.
986 */
989 {
996 /*
997 * Fetch all the field information.
998 */
1006 /* class->field.first and idx points into the fieldptr table */
1010 /* FIELD signature == 0x06 */
1019 }
1020 ftype = mono_metadata_parse_type_full (m, container, MONO_PARSE_FIELD, cols [MONO_FIELD_FLAGS], sig + 1, &sig);
1024 //FIXME do we leak here?
1027 }
1031 }
1034 }
1036 /**
1037 * mono_class_setup_fields:
1038 * @class: The class to initialize
1039 *
1040 * Initializes the class->fields.
1041 * LOCKING: Assumes the loader lock is held.
1042 */
1043 static void
1045 {
1052 gboolean explicit_size;
1060 if (class->generic_class && class->generic_class->container_class->image->dynamic && !class->generic_class->container_class->wastypebuilder) {
1061 /*
1062 * This happens when a generic instance of an unfinished generic typebuilder
1063 * is used as an element type for creating an array type. We can't initialize
1064 * the fields of this class using the fields of gklass, since gklass is not
1065 * finished yet, fields could be added to it later.
1066 */
1068 }
1075 }
1082 /* For generic instances, class->parent might not have been initialized */
1088 /* we use |= since it may have been set already */
1094 }
1099 /* Get the real size */
1100 explicit_size = mono_metadata_packing_from_typedef (class->image, class->type_token, &packing_size, &real_size);
1106 }
1111 }
1115 }
1120 /* Prevent infinite loops if the class references itself */
1137 }
1138 }
1140 /*
1141 * Fetch all the field information.
1142 */
1153 /*This memory must come from the image mempool as we don't have a chance to free it.*/
1154 field->type = mono_class_inflate_generic_type_no_copy (class->image, gfield->type, mono_class_get_context (class));
1163 /* class->field.first and idx points into the fieldptr table */
1165 /* The name is needed for fieldrefs */
1169 /* FIELD signature == 0x06 */
1171 field->type = mono_metadata_parse_type_full (m, container, MONO_PARSE_FIELD, cols [MONO_FIELD_FLAGS], sig + 1, &sig);
1175 }
1179 guint32 offset;
1185 }
1186 }
1188 /* Only do these checks if we still think this type is blittable */
1198 }
1199 }
1204 }
1206 /* The def_value of fields is compute lazily during vtable creation */
1207 }
1217 }
1220 }
1225 }
1227 /**
1228 * mono_class_setup_fields_locking:
1229 * @class: The class to initialize
1230 *
1231 * Initializes the class->fields array of fields.
1232 * Aquires the loader lock.
1233 */
1234 static void
1236 {
1240 }
1242 /*
1243 * mono_class_has_references:
1244 *
1245 * Returns whenever @klass->has_references is set, initializing it if needed.
1246 * Aquires the loader lock.
1247 */
1248 static gboolean
1250 {
1252 /* Be conservative */
1258 }
1259 }
1261 /* useful until we keep track of gc-references in corlib etc. */
1262 #ifdef HAVE_SGEN_GC
1263 #define IS_GC_REFERENCE(t) FALSE
1264 #else
1265 #define IS_GC_REFERENCE(t) ((t)->type == MONO_TYPE_U && class->image == mono_defaults.corlib)
1266 #endif
1268 /*
1269 * mono_type_get_basic_type_from_generic:
1270 * @type: a type
1271 *
1272 * Returns a closed type corresponding to the possibly open type
1273 * passed to it.
1274 */
1275 MonoType*
1277 {
1278 /* When we do generic sharing we let type variables stand for reference types. */
1282 }
1284 /*
1285 * mono_class_layout_fields:
1286 * @class: a class
1287 *
1288 * Compute the placement of fields inside an object or struct, according to
1289 * the layout rules and set the following fields in @class:
1290 * - has_references (if the class contains instance references firled or structs that contain references)
1291 * - has_static_refs (same, but for static fields)
1292 * - instance_size (size of the object in memory)
1293 * - class_size (size needed for the static fields)
1294 * - size_inited (flag set when the instance_size is set)
1295 *
1296 * LOCKING: this is supposed to be called with the loader lock held.
1297 */
1298 void
1300 {
1308 /*
1309 * When we do generic sharing we need to have layout
1310 * information for open generic classes (either with a generic
1311 * context containing type variables or with a generic
1312 * container), so we don't return in that case anymore.
1313 */
1315 /*
1316 * Enable GC aware auto layout: in this mode, reference
1317 * fields are grouped together inside objects, increasing collector
1318 * performance.
1319 * Requires that all classes whose layout is known to native code be annotated
1320 * with [StructLayout (LayoutKind.Sequential)]
1321 * Value types have gc_aware_layout disabled by default, as per
1322 * what the default is for other runtimes.
1323 */
1324 /* corlib is missing [StructLayout] directives in many places */
1329 /* from System.dll, used in metadata/process.h */
1332 }
1334 /* Compute klass->has_references */
1335 /*
1336 * Process non-static fields first, since static fields might recursively
1337 * refer to the class itself.
1338 */
1347 if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype)))))
1349 }
1350 }
1360 if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype)))))
1362 }
1363 }
1372 if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype))))) {
1375 else
1377 }
1378 }
1380 /*
1381 * Compute field layout and total size (not considering static fields)
1382 */
1390 else
1398 else
1403 gint32 align;
1404 guint32 size;
1417 if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype))))) {
1423 }
1424 }
1428 /* This field is a hack inserted by MCS to empty structures */
1430 }
1434 /* FIXME (LAMESPEC): should we also change the min alignment according to pack? */
1436 /* if the field has managed references, we need to force-align it
1437 * see bug #77788
1438 */
1439 if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype)))))
1447 }
1454 }
1455 }
1460 gint32 align;
1461 guint32 size;
1466 /*
1467 * There must be info about all the fields in a type if it
1468 * uses explicit layout.
1469 */
1479 /*
1480 * When we get here, field->offset is already set by the
1481 * loader (for either runtime fields or fields loaded from metadata).
1482 * The offset is from the start of the object: this works for both
1483 * classes and valuetypes.
1484 */
1488 if (MONO_TYPE_IS_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype))))) {
1491 }
1492 }
1494 /*
1495 * Calc max size.
1496 */
1498 }
1501 }
1504 /*
1505 * For small structs, set min_align to at least the struct size to improve
1506 * performance, and since the JIT memset/memcpy code assumes this and generates
1507 * unaligned accesses otherwise. See #78990 for a testcase.
1508 */
1511 }
1515 /*
1516 * Compute static field layout and size
1517 */
1519 gint32 align;
1520 guint32 size;
1524 if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC) || field->type->attrs & FIELD_ATTRIBUTE_LITERAL)
1534 }
1535 }
1539 {
1549 /* .ctor */
1554 }
1556 }
1558 /*
1559 * mono_class_setup_methods:
1560 * @class: a class
1561 *
1562 * Initializes the 'methods' array in the klass.
1563 * Calling this method should be avoided if possible since it allocates a lot
1564 * of long-living MonoMethod structures.
1565 * Methods belonging to an interface are assigned a sequential slot starting
1566 * from 0.
1567 */
1568 void
1570 {
1582 }
1590 /* The + 1 makes this always non-NULL to pass the check in mono_class_setup_methods () */
1597 }
1612 }
1635 }
1636 /* element Get (idx11, [idx2, ...]) */
1645 /* element& Address (idx11, [idx2, ...]) */
1654 /* void Set (idx11, [idx2, ...], element) */
1666 setup_generic_array_ifaces (class, class->interfaces [i], methods, first_generic + i * count_generic);
1670 int idx = mono_metadata_translate_token_index (class->image, MONO_TABLE_METHOD, class->method.first + i + 1);
1672 }
1673 }
1679 /* Needed because of the double-checking locking pattern */
1688 }
1690 /*
1691 * mono_class_get_method_by_index:
1692 *
1693 * Returns class->methods [index], initializing class->methods if neccesary.
1694 *
1695 * LOCKING: Acquires the loader lock.
1696 */
1697 MonoMethod*
1699 {
1700 /* Avoid calling setup_methods () if possible */
1707 /*
1708 * If setup_methods () is called later for this class, no duplicates are created,
1709 * since inflate_generic_method guarantees that only one instance of a method
1710 * is created for each context.
1711 */
1712 /*
1713 mono_class_setup_methods (class);
1714 g_assert (m == class->methods [index]);
1715 */
1721 }
1722 }
1724 /*
1725 * mono_class_get_inflated_method:
1726 *
1727 * Given an inflated class CLASS and a method METHOD which should be a method of
1728 * CLASS's generic definition, return the inflated method corresponding to METHOD.
1729 */
1730 MonoMethod*
1732 {
1741 else
1742 return mono_class_inflate_generic_method_full (gklass->methods [i], class, mono_class_get_context (class));
1743 }
1744 }
1747 }
1749 /*
1750 * mono_class_get_vtable_entry:
1751 *
1752 * Returns class->vtable [offset], computing it if neccesary.
1753 * LOCKING: Acquires the loader lock.
1754 */
1755 MonoMethod*
1757 {
1761 /*
1762 * szarrays do not overwrite any methods of Array, so we can avoid
1763 * initializing their vtables in some cases.
1764 */
1768 }
1779 }
1781 /*
1782 * We have to add static rgctx wrappers somewhere, we do it here,
1783 * altough it should probably be done by the JIT.
1784 */
1788 }
1790 static void
1792 {
1797 guint32 last;
1807 }
1834 }
1836 class->ext->property.first = mono_metadata_properties_from_typedef (class->image, mono_metadata_token_index (class->type_token) - 1, &last);
1842 properties = mono_image_alloc0 (class->image, sizeof (MonoProperty) * class->ext->property.count);
1844 mono_metadata_decode_table_row (class->image, MONO_TABLE_PROPERTY, i, cols, MONO_PROPERTY_SIZE);
1847 properties [i - class->ext->property.first].name = mono_metadata_string_heap (class->image, cols [MONO_PROPERTY_NAME]);
1856 /* It seems like the MONO_METHOD_SEMA_METHOD column needs no remapping */
1857 method = mono_get_method (class->image, MONO_TOKEN_METHOD_DEF | cols [MONO_METHOD_SEMA_METHOD], class);
1858 else
1870 }
1871 }
1872 }
1873 }
1874 /*Flush any pending writes as we do double checked locking on class->properties */
1877 /* Leave this assignment as the last op in the function */
1881 }
1885 {
1890 ;
1898 }
1900 static void
1902 {
1906 guint32 last;
1917 }
1939 event->add = gevent->add ? mono_class_inflate_generic_method_full (gevent->add, class, context) : NULL;
1940 event->remove = gevent->remove ? mono_class_inflate_generic_method_full (gevent->remove, class, context) : NULL;
1941 event->raise = gevent->raise ? mono_class_inflate_generic_method_full (gevent->raise, class, context) : NULL;
1944 }
1948 }
1950 class->ext->event.first = mono_metadata_events_from_typedef (class->image, mono_metadata_token_index (class->type_token) - 1, &last);
1972 /* It seems like the MONO_METHOD_SEMA_METHOD column needs no remapping */
1973 method = mono_get_method (class->image, MONO_TOKEN_METHOD_DEF | cols [MONO_METHOD_SEMA_METHOD], class);
1974 else
1994 n++;
1996 }
1998 /* NULL terminated */
2001 }
2004 }
2005 }
2006 }
2007 /*Flush any pending writes as we do double checked locking on class->properties */
2010 /* Leave this assignment as the last op in the function */
2014 }
2016 /*
2017 * Global pool of interface IDs, represented as a bitset.
2018 * LOCKING: this is supposed to be accessed with the loader lock held.
2019 */
2022 /*
2023 * mono_unload_interface_ids:
2024 * @bitset: bit set of interface IDs
2025 *
2026 * When an image is unloaded, the interface IDs associated with
2027 * the image are put back in the global pool of IDs so the numbers
2028 * can be reused.
2029 */
2030 void
2032 {
2036 }
2038 /*
2039 * mono_get_unique_iid:
2040 * @class: interface
2041 *
2042 * Assign a unique integer ID to the interface represented by @class.
2043 * The ID will positive and as small as possible.
2044 * LOCKING: this is supposed to be called with the loader lock held.
2045 * Returns: the new ID.
2046 */
2047 static guint
2049 {
2056 }
2065 }
2067 /* set the bit also in the per-image set */
2073 }
2076 }
2087 }
2088 printf ("Interface: assigned id %d to %s|%s|%d\n", iid, class->image->name, type_name, generic_id);
2090 }
2094 }
2096 static void
2098 {
2113 }
2114 }
2116 GPtrArray*
2118 {
2123 }
2125 static int
2131 }
2133 int
2136 itf,
2140 compare_interface_ids);
2145 }
2146 }
2148 static void
2154 printf ("Packed interface table for class %s has size %d\n", klass->name, klass->interface_offsets_count);
2166 else
2170 for (i = 0; i < ((((klass->max_interface_id + 1) >> 3)) + (((klass->max_interface_id + 1) & 7)? 1 :0)); i++)
2186 }
2188 }
2189 ancestor_level ++;
2191 }
2192 }
2196 {
2201 }
2205 {
2207 }
2209 static void
2211 {
2231 }
2233 /* this won't be needed once bug #325495 is completely fixed
2234 * though we'll need something similar to know which interfaces to allow
2235 * in arrays when they'll be lazyly created
2236 *
2237 * FIXME: System.Array/InternalEnumerator don't need all this interface fabrication machinery.
2238 * MS returns diferrent types based on which instance is called. For example:
2239 * object obj = new byte[10][];
2240 * Type a = ((IEnumerable<byte[]>)obj).GetEnumerator ().GetType ();
2241 * Type b = ((IEnumerable<IList<byte>>)obj).GetEnumerator ().GetType ();
2242 * a != b ==> true
2243 *
2244 * Fixing this should kill quite some code, save some bits and improve compatbility.
2245 */
2248 {
2257 gboolean internal_enumerator;
2258 gboolean eclass_is_valuetype;
2263 }
2268 if (class->generic_class && class->nested_in == mono_defaults.array_class && strcmp (class->name, "InternalEnumerator`1") == 0) {
2269 /*
2270 * For a Enumerator<T[]> we need to get the list of interfaces for T.
2271 */
2280 }
2281 }
2283 /*
2284 * with this non-lazy impl we can't implement all the interfaces so we do just the minimal stuff
2285 * for deep levels of arrays of arrays (string[][] has all the interfaces, string[][][] doesn't)
2286 */
2296 }
2300 /*
2301 * Arrays in 2.0 need to implement a number of generic interfaces
2302 * (IList`1, ICollection`1, IEnumerable`1 for a number of types depending
2303 * on the element class). We collect the types needed to build the
2304 * instantiations in interfaces at intervals of 3, because 3 are
2305 * the generic interfaces needed to implement.
2306 */
2310 /* IList, ICollection, IEnumerable */
2316 }
2328 idepth--;
2330 /* we add object for interfaces and the supertypes for the other
2331 * types. The last of the supertypes is the element class itself which we
2332 * already created the explicit interfaces for (so we include it for IEnumerator
2333 * and exclude it for arrays).
2334 */
2336 interface_count++;
2337 else
2343 }
2344 /* IList, ICollection, IEnumerable */
2348 real_count += (MONO_CLASS_IS_INTERFACE (eclass) ? 1 : idepth) + eclass->interface_offsets_count;
2351 }
2362 }
2363 }
2368 }
2373 }
2374 }
2378 }
2379 }
2381 /* instantiate the generic interfaces */
2388 }
2391 /* instantiate IEnumerator<iface> */
2394 }
2398 interfaces [j] = inflate_class_one_arg (generic_ienumerator_class, mono_defaults.object_class);
2399 j ++;
2403 j ++;
2404 }
2405 }
2407 interfaces [j] = inflate_class_one_arg (generic_ienumerator_class, eclass->interfaces_packed [i]);
2408 j ++;
2409 }
2411 interfaces [j++] = inflate_class_one_arg (generic_ienumerator_class, array_class_get_if_rank (valuetype_types [0], original_rank));
2412 }
2414 interfaces [j] = inflate_class_one_arg (generic_ienumerator_class, array_class_get_if_rank (valuetype_types [1], original_rank));
2415 }
2416 #if 0
2417 {
2423 }
2425 }
2426 #endif
2429 }
2431 static int
2433 {
2438 }
2440 }
2442 /*
2443 * LOCKING: this is supposed to be called with the loader lock held.
2444 */
2445 static int
2447 {
2458 /*
2459 * get the implicit generic interfaces for either the arrays or for System.Array/InternalEnumerator<T>
2460 * implicit interfaces have the property that they are assigned the same slot in the
2461 * vtables for compatible interfaces
2462 */
2463 array_interfaces = get_implicit_generic_array_interfaces (class, &num_array_interfaces, &is_enumerator);
2465 /* compute maximum number of slots and maximum interface id */
2476 }
2483 }
2485 }
2486 }
2492 }
2497 }
2499 /* compute vtable offset for interfaces */
2506 }
2515 }
2517 }
2532 }
2533 }
2535 }
2536 }
2541 }
2547 ienumerator_offset = interface_offsets_full [class->interfaces [ienumerator_idx]->interface_id];
2553 else
2555 /*g_print ("type %s has %s offset at %d (%s)\n", class->name, ic->name, interface_offsets_full [ic->interface_id], class->interfaces [0]->name);*/
2556 }
2560 int icollection_iface_idx = find_array_interface (class->interfaces [ilist_iface_idx], "ICollection`1");
2561 int ienumerable_iface_idx = find_array_interface (class->interfaces [ilist_iface_idx], "IEnumerable`1");
2563 icollection_offset = interface_offsets_full [class->interfaces [ilist_iface_idx]->interfaces [icollection_iface_idx]->interface_id];
2564 ienumerable_offset = interface_offsets_full [class->interfaces [ilist_iface_idx]->interfaces [ienumerable_iface_idx]->interface_id];
2575 else
2577 /*g_print ("type %s has %s offset at %d (%s)\n", class->name, ic->name, interface_offsets_full [ic->interface_id], class->interfaces [0]->name);*/
2578 }
2579 }
2580 }
2584 interface_offsets_count ++;
2585 }
2586 }
2588 /*
2589 * We might get called twice: once from mono_class_init () then once from
2590 * mono_class_setup_vtable ().
2591 */
2596 class->interfaces_packed = mono_image_alloc (class->image, sizeof (MonoClass*) * interface_offsets_count);
2597 class->interface_offsets_packed = mono_image_alloc (class->image, sizeof (guint16) * interface_offsets_count);
2598 class->interface_bitmap = mono_image_alloc0 (class->image, (sizeof (guint8) * ((max_iid + 1) >> 3)) + (((max_iid + 1) & 7)? 1 :0));
2604 /*if (num_array_interfaces)
2605 g_print ("type %s has %s offset at %d\n", mono_type_get_name_full (&class->byval_arg, 0), mono_type_get_name_full (&interfaces_full [i]->byval_arg, 0), interface_offsets_full [i]);*/
2606 interface_offsets_count ++;
2607 }
2608 }
2609 }
2615 //printf ("JUST DONE: ");
2616 //print_implemented_interfaces (class);
2619 }
2621 /*
2622 * Setup interface offsets for interfaces.
2623 * Initializes:
2624 * - class->max_interface_id
2625 * - class->interface_offsets_count
2626 * - class->interfaces_packed
2627 * - class->interface_offsets_packed
2628 * - class->interface_bitmap
2629 */
2630 void
2632 {
2638 }
2640 /*
2641 * mono_class_setup_vtable:
2642 *
2643 * Creates the generic vtable of CLASS.
2644 * Initializes the following fields in MonoClass:
2645 * - vtable
2646 * - vtable_size
2647 * Plus all the fields initialized by setup_interface_offsets ().
2648 * If there is an error during vtable construction, class->exception_type is set.
2649 *
2650 * LOCKING: Acquires the loader lock.
2651 */
2652 void
2654 {
2657 guint32 type_token;
2666 /* The debugger currently depends on this */
2670 /* This sets method->slot for all methods if this is an interface */
2673 }
2680 }
2690 }
2706 }
2707 }
2711 }
2714 }
2716 /* The following call fails if there are missing methods in the type */
2718 }
2728 }
2730 static void
2732 {
2733 MonoSecurityCoreCLRLevel override_level = mono_security_core_clr_method_level (override, FALSE);
2738 }
2741 #define DEBUG_INTERFACE_VTABLE_CODE 0
2742 #define TRACE_INTERFACE_VTABLE_CODE 0
2743 #define VERIFY_INTERFACE_VTABLE_CODE 0
2745 #if (TRACE_INTERFACE_VTABLE_CODE|DEBUG_INTERFACE_VTABLE_CODE)
2746 #define DEBUG_INTERFACE_VTABLE(stmt) do {\
2747 stmt;\
2748 } while (0)
2749 #else
2750 #define DEBUG_INTERFACE_VTABLE(stmt)
2751 #endif
2753 #if TRACE_INTERFACE_VTABLE_CODE
2754 #define TRACE_INTERFACE_VTABLE(stmt) do {\
2755 stmt;\
2756 } while (0)
2757 #else
2758 #define TRACE_INTERFACE_VTABLE(stmt)
2759 #endif
2761 #if VERIFY_INTERFACE_VTABLE_CODE
2762 #define VERIFY_INTERFACE_VTABLE(stmt) do {\
2763 stmt;\
2764 } while (0)
2765 #else
2766 #define VERIFY_INTERFACE_VTABLE(stmt)
2767 #endif
2770 #if (TRACE_INTERFACE_VTABLE_CODE|DEBUG_INTERFACE_VTABLE_CODE)
2773 {
2783 }
2789 }
2793 }
2794 static void
2802 }
2804 #endif
2805 static gboolean
2806 check_interface_method_override (MonoClass *class, MonoMethod *im, MonoMethod *cm, gboolean require_newslot, gboolean interface_is_explicitly_implemented_by_class, gboolean slot_is_empty, gboolean security_enabled) {
2811 }
2817 }
2821 }
2824 }
2825 }
2826 if (! mono_metadata_signature_equal (mono_method_signature (cm), mono_method_signature (im))) {
2831 }
2833 /* CAS - SecurityAction.InheritanceDemand on interface */
2836 }
2851 }
2855 }
2856 if (! mono_metadata_signature_equal (mono_method_signature (cm), mono_method_signature (im))) {
2861 }
2865 }
2869 }
2870 if ((ic_name == NULL) || ((strcmp (ic_name, "IEnumerable`1") != 0) && (strcmp (ic_name, "ICollection`1") != 0) && (strcmp (ic_name, "IList`1") != 0))) {
2873 }
2879 }
2884 }
2885 subname ++;
2889 }
2894 }
2895 subname ++;
2899 }
2902 /* CAS - SecurityAction.InheritanceDemand on interface */
2905 }
2912 }
2913 }
2915 #if (TRACE_INTERFACE_VTABLE_CODE|DEBUG_INTERFACE_VTABLE_CODE)
2916 static void
2924 mono_class_get_namespace (method_class), mono_class_get_name (method_class), mono_method_get_name (method),
2925 mono_class_get_namespace (override_class), mono_class_get_name (override_class), mono_method_get_name (override));
2926 }
2927 static void
2935 }
2936 }
2937 static void
2938 print_vtable_full (MonoClass *class, MonoMethod** vtable, int size, int first_non_interface_slot, const char *message, gboolean print_interfaces) {
2948 }
2954 }
2962 }
2963 }
2966 }
2967 #endif
2969 #if VERIFY_INTERFACE_VTABLE_CODE
2970 static int
2972 {
2977 }
2979 }
2981 static void
2983 {
3007 printf ("\tInvalid method %s at index %d with vtable of length %d\n", full_name, slot, class->vtable_size);
3009 }
3012 char *other_name = class->vtable [slot] ? mono_method_full_name (class->vtable [slot], TRUE) : g_strdup ("[null value]");
3015 }
3018 }
3020 }
3021 #endif
3023 static void
3024 print_unimplemented_interface_method_info (MonoClass *class, MonoClass *ic, MonoMethod *im, int im_slot, MonoMethod **overrides, int onum) {
3031 }
3034 mono_type_get_name (&ic->byval_arg), im->name, method_signature, class->name_space, class->name);
3043 }
3044 }
3046 /*
3047 * LOCKING: this is supposed to be called with the loader lock held.
3048 */
3049 void
3051 {
3059 gpointer class_iter;
3060 #if (DEBUG_INTERFACE_VTABLE_CODE|TRACE_INTERFACE_VTABLE_CODE)
3062 #endif
3072 }
3075 }
3082 }
3089 /* printf ("METAINIT %s.%s\n", class->name_space, class->name); */
3095 /* Optimized version for generic instances */
3106 tmp [i] = mono_class_inflate_generic_method_full (gklass->vtable [i], class, mono_class_get_context (class));
3108 }
3112 /* Have to set method->slot for abstract virtual methods */
3117 }
3120 }
3128 // Also inherit parent interface vtables, just as a starting point.
3129 // This is needed otherwise bug-77127.exe fails when the property methods
3130 // have different names in the iterface and the class, because for child
3131 // classes the ".override" information is not used anymore.
3141 TRACE_INTERFACE_VTABLE (printf (" +++ Inheriting interface %s.%s\n", parent_interface->name_space, parent_interface->name));
3144 TRACE_INTERFACE_VTABLE (printf (" --- Inheriting: [%03d][(%03d)+(%03d)] => [%03d][(%03d)+(%03d)]\n",
3147 }
3148 }
3150 }
3151 }
3153 TRACE_INTERFACE_VTABLE (print_vtable_full (class, vtable, cur_slot, first_non_interface_slot, "AFTER INHERITING PARENT VTABLE", TRUE));
3154 /* override interface methods */
3169 }
3170 }
3172 TRACE_INTERFACE_VTABLE (print_vtable_full (class, vtable, cur_slot, first_non_interface_slot, "AFTER OVERRIDING INTERFACE METHODS", FALSE));
3174 // Loop on all implemented interfaces...
3178 gboolean interface_is_explicitly_implemented_by_class;
3186 // Check if this interface is explicitly implemented (instead of just inherited)
3190 for (implemented_interfaces_index = 0; implemented_interfaces_index < class->interface_count; implemented_interfaces_index++) {
3194 }
3195 }
3198 }
3200 // Loop on all interface methods...
3204 MonoMethod *override_im = (override_map != NULL) ? g_hash_table_lookup (override_map, im) : NULL;
3209 // If there is an explicit implementation, just use it right away,
3210 // otherwise look for a matching method
3213 gpointer iter;
3216 // First look for a suitable method among the class methods
3219 TRACE_INTERFACE_VTABLE (printf (" For slot %d ('%s'.'%s':'%s'), trying method '%s'.'%s':'%s'... [EXPLICIT IMPLEMENTATION = %d][SLOT IS NULL = %d]", im_slot, ic->name_space, ic->name, im->name, cm->klass->name_space, cm->klass->name, cm->name, interface_is_explicitly_implemented_by_class, (vtable [im_slot] == NULL)));
3220 if (check_interface_method_override (class, im, cm, TRUE, interface_is_explicitly_implemented_by_class, (vtable [im_slot] == NULL), security_enabled)) {
3223 /* Why do we need this? */
3226 }
3227 }
3229 }
3231 // If the slot is still empty, look in all the inherited virtual methods...
3234 // Reverse order, so that last added methods are preferred
3238 TRACE_INTERFACE_VTABLE ((cm != NULL) && printf (" For slot %d ('%s'.'%s':'%s'), trying (ancestor) method '%s'.'%s':'%s'... ", im_slot, ic->name_space, ic->name, im->name, cm->klass->name_space, cm->klass->name, cm->name));
3239 if ((cm != NULL) && check_interface_method_override (class, im, cm, FALSE, FALSE, TRUE, security_enabled)) {
3242 /* Why do we need this? */
3245 }
3247 }
3249 }
3250 }
3253 }
3254 }
3255 }
3257 // If the class is not abstract, check that all its interface slots are full.
3258 // The check is done here and not directly at the end of the loop above because
3259 // it can happen (for injected generic array interfaces) that the same slot is
3260 // processed multiple times (those interfaces have overlapping slots), and it
3261 // will not always be the first pass the one that fills the slot.
3277 TRACE_INTERFACE_VTABLE (printf (" [class is not abstract, checking slot %d for interface '%s'.'%s', method %s, slot check is %d]\n",
3285 }
3286 }
3287 }
3288 }
3290 TRACE_INTERFACE_VTABLE (print_vtable_full (class, vtable, cur_slot, first_non_interface_slot, "AFTER SETTING UP INTERFACE METHODS", FALSE));
3293 /*
3294 * If the method is REUSE_SLOT, we must check in the
3295 * base class for a method to override.
3296 */
3300 gpointer k_iter;
3313 }
3318 /* CAS - SecurityAction.InheritanceDemand */
3321 }
3332 }
3333 }
3336 }
3339 }
3346 }
3348 /* override non interface methods */
3361 }
3362 }
3364 /*
3365 * If a method occupies more than one place in the vtable, and it is
3366 * overriden, then change the other occurances too.
3367 */
3374 }
3377 }
3386 /* Check that the vtable_size value computed in mono_class_init () is correct */
3390 }
3392 /* Try to share the vtable with our parent. */
3393 if (class->parent && (class->parent->vtable_size == class->vtable_size) && (memcmp (class->parent->vtable, vtable, sizeof (gpointer) * class->vtable_size) == 0)) {
3401 }
3403 DEBUG_INTERFACE_VTABLE (print_vtable_full (class, class->vtable, class->vtable_size, first_non_interface_slot, "FINALLY", FALSE));
3411 icount++;
3413 printf ("VTable %s (vtable entries = %d, interfaces = %d)\n", mono_type_full_name (&class->byval_arg),
3423 }
3424 }
3436 }
3444 }
3445 }
3446 }
3447 }
3450 }
3452 /*
3453 * mono_method_get_vtable_slot:
3454 *
3455 * Returns method->slot, computing it if neccesary.
3456 * LOCKING: Acquires the loader lock.
3457 */
3458 int
3460 {
3464 }
3466 }
3468 /**
3469 * mono_method_get_vtable_index:
3470 * @method: a method
3471 *
3472 * Returns the index into the runtime vtable to access the method or,
3473 * in the case of a virtual generic method, the virtual generic method
3474 * thunk.
3475 */
3476 int
3478 {
3483 }
3485 }
3492 static void
3494 {
3507 }
3514 }
3515 }
3525 static int
3527 {
3536 count_generic++;
3538 }
3539 }
3559 }
3565 i++;
3566 }
3567 /*g_print ("array generic methods: %d\n", count_generic);*/
3572 }
3574 static void
3576 {
3577 MonoGenericContext tmp_context;
3582 //g_print ("setting up array interface: %s\n", mono_type_get_name_full (&iface->byval_arg, 0));
3589 methods [pos++] = mono_marshal_get_generic_array_helper (class, iface, generic_array_method_info [i].name, inflated);
3590 }
3591 }
3595 {
3604 }
3606 static void
3608 {
3613 exception_data = concat_two_strings_with_zero (class->image, error->class_name, error->assembly_name);
3617 exception_data = concat_two_strings_with_zero (class->image, error->class_name, error->member_name);
3626 else
3634 }
3640 msg = "Cannot resolve dependency to assembly '%s' because it has not been preloaded. When using the ReflectionOnly APIs, dependent assemblies must be pre-loaded or loaded on demand through the ReflectionOnlyAssemblyResolve event.";
3641 else
3646 }
3654 }
3657 }
3659 static void
3661 {
3673 }
3675 /**
3676 * mono_class_init:
3677 * @class: the class to initialize
3678 *
3679 * Compute the instance_size, class_size and other infos that cannot be
3680 * computed at mono_class_get() time. Also compute vtable_size if possible.
3681 * Returns TRUE on success or FALSE if there was a problem in loading
3682 * the type (incorrect assemblies, missing assemblies, methods, etc).
3683 *
3684 * LOCKING: Acquires the loader lock.
3685 */
3686 gboolean
3688 {
3690 MonoCachedClassInfo cached_info;
3691 gboolean has_cached_info;
3696 /* Double-checking locking pattern */
3700 /*g_print ("Init class %s\n", class->name);*/
3702 /* We do everything inside the lock to prevent races */
3707 /* Somebody might have gotten in before us */
3709 }
3713 /* this indicates a cyclic dependency */
3715 }
3719 /* CAS - SecurityAction.InheritanceDemand */
3720 if (mono_is_security_manager_active () && class->parent && (class->parent->flags & TYPE_ATTRIBUTE_HAS_SECURITY)) {
3722 }
3738 // FIXME: Why is this needed ?
3743 }
3750 if (class->generic_class || class->image->dynamic || !class->type_token || (has_cached_info && !cached_info.has_nested_classes))
3753 /*
3754 * Computes the size used by the fields, and their locations
3755 */
3765 }
3766 else
3772 }
3773 }
3775 /* Initialize arrays */
3782 }
3783 }
3790 /*
3791 * Initialize the rest of the data without creating a generic vtable if possible.
3792 * If possible, also compute vtable_size, so mono_class_create_runtime_vtable () can
3793 * also avoid computing a generic vtable.
3794 */
3796 /* AOT case */
3804 /* SZARRAY case */
3810 }
3814 /* Generic instance case */
3825 /* General case */
3827 /* ghcimpl is not currently used
3828 class->ghcimpl = 1;
3829 if (class->parent) {
3830 MonoMethod *cmethod = class->vtable [ghc_slot];
3831 if (cmethod->is_inflated)
3832 cmethod = ((MonoMethodInflated*)cmethod)->declaring;
3833 if (cmethod == default_ghc) {
3834 class->ghcimpl = 0;
3835 }
3836 }
3837 */
3839 /* Interfaces and valuetypes are not supposed to have finalizers */
3849 /* FIXME: Optimize this */
3854 }
3857 /* Check that this is really the finalizer method */
3869 }
3870 }
3871 }
3872 }
3873 }
3875 /* C# doesn't allow interfaces to have cctors */
3881 /* The find_method function ignores the 'flags' argument */
3893 }
3894 }
3895 }
3896 }
3897 }
3900 /*
3901 * This is an embedding API break, since the caller might assume that
3902 * mono_class_init () constructs a generic vtable, so vtable construction errors
3903 * are visible right after the mono_class_init (), and not after
3904 * mono_class_vtable ().
3905 */
3907 /* This will compute class->parent->vtable_size for some classes */
3912 /* FIXME: Get rid of this somehow */
3916 }
3920 }
3926 }
3929 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, concat_two_strings_with_zero (class->image, class->name, class->image->assembly_name));
3931 }
3935 fail:
3938 leave:
3939 /* Because of the double-checking locking pattern */
3949 }
3957 }
3959 static gboolean
3961 {
3962 /* FIXME: allow the dynamic case for our compilers and with full trust */
3965 else
3967 }
3969 /*
3970 * LOCKING: this assumes the loader lock is held
3971 */
3972 void
3974 {
3987 /*
3988 * do not set the valuetype bit for System.ValueType.
3989 * class->valuetype = 1;
3990 */
3993 /*
3994 * do not set the valuetype bit for System.Enum.
3995 * class->valuetype = 1;
3996 */
4005 }
4006 }
4019 }
4024 }
4030 }
4045 }
4054 }
4069 }
4075 }
4080 }
4084 }
4085 }
4087 }
4092 }
4094 /*
4095 * LOCKING: this assumes the loader lock is held
4096 */
4097 void
4099 {
4100 gboolean system_namespace;
4105 /* if root of the hierarchy */
4110 }
4115 }
4118 /* Imported COM Objects always derive from __ComObject. */
4123 }
4125 /* set the parent to something useful and safe, but mark the type as broken */
4128 }
4133 /*
4134 * If the parent is a generic instance, we may get
4135 * called before it is fully initialized, especially
4136 * before it has its name.
4137 */
4139 }
4146 else
4158 }
4160 if (class->parent->enumtype || (is_corlib_image (class->parent->image) && (strcmp (class->parent->name, "ValueType") == 0) &&
4163 if (is_corlib_image (class->parent->image) && ((strcmp (class->parent->name, "Enum") == 0) && (strcmp (class->parent->name_space, "System") == 0))) {
4165 }
4166 /*class->enumtype = class->parent->enumtype; */
4169 /* initialize com types if COM interfaces are present */
4173 }
4175 }
4177 /*
4178 * mono_class_setup_supertypes:
4179 * @class: a class
4180 *
4181 * Build the data structure needed to make fast type checks work.
4182 * This currently sets two fields in @class:
4183 * - idepth: distance between @class and System.Object in the type
4184 * hierarchy + 1
4185 * - supertypes: array of classes: each element has a class in the hierarchy
4186 * starting from @class up to System.Object
4187 *
4188 * LOCKING: this assumes the loader lock is held
4189 */
4190 void
4192 {
4202 else
4210 memcpy (class->supertypes, class->parent->supertypes, class->parent->idepth * sizeof (gpointer));
4213 }
4214 }
4216 /**
4217 * mono_class_create_from_typedef:
4218 * @image: image where the token is valid
4219 * @type_token: typedef token
4220 *
4221 * Create the MonoClass* representing the specified type token.
4222 * @type_token must be a TypeDef token.
4223 */
4226 {
4237 guint32 nesting_tokeen;
4241 if ((class = mono_internal_hash_table_lookup (&image->class_cache, GUINT_TO_POINTER (type_token)))) {
4244 }
4268 /*
4269 * Check whether we're a generic type definition.
4270 */
4276 }
4282 /*WARNING: this must satisfy mono_metadata_type_hash*/
4288 }
4296 }
4297 }
4299 /* do this early so it's available for interfaces in setup_mono_type () */
4305 /* uses ->valuetype, which is initialized by mono_class_setup_parent above */
4314 }
4319 }
4324 #if PLATFORM_WIN32
4327 #endif
4331 /*g_print ("Load class %s\n", name);*/
4333 /*
4334 * Compute the field and method lists
4335 */
4346 }
4351 else
4356 else
4359 /* reserve space to store vector pointer in arrays */
4363 }
4371 }
4373 }
4375 /*
4376 * If we're a generic type definition, load the constraints.
4377 * We must do this after the class has been constructed to make certain recursive scenarios
4378 * work.
4379 */
4384 if (class->image->assembly_name && !strcmp (class->image->assembly_name, "Mono.Simd") && !strcmp (nspace, "Mono.Simd")) {
4386 class->simd_type = !strcmp (name + 6, "2d") || !strcmp (name + 6, "2ul") || !strcmp (name + 6, "2l") || !strcmp (name + 6, "4f") || !strcmp (name + 6, "4ui") || !strcmp (name + 6, "4i") || !strcmp (name + 6, "8s") || !strcmp (name + 6, "8us") || !strcmp (name + 6, "16b") || !strcmp (name + 6, "16sb");
4387 }
4394 }
4396 /** is klass Nullable<T>? */
4397 gboolean
4399 {
4402 }
4405 /** if klass is T? return T */
4406 MonoClass*
4408 {
4411 }
4413 /*
4414 * Create the `MonoClass' for an instantiation of a generic type.
4415 * We only do this if we actually need it.
4416 */
4417 MonoClass*
4419 {
4426 }
4434 /*
4435 * FIXME: the nested type context should include everything the
4436 * nesting context should have, but it may also have additional
4437 * generic parameters...
4438 */
4441 }
4467 /*
4468 * We're not interested in the nested classes of a generic instance.
4469 * We use the generic type definition to look for nested classes.
4470 */
4473 klass->parent = mono_class_inflate_generic_class (gklass->parent, mono_generic_class_get_context (gclass));
4474 }
4482 }
4490 /*
4491 * For enums, gklass->fields might not been set, but instance_size etc. is
4492 * already set in mono_reflection_create_internal_class (). For non-enums,
4493 * these will be computed normally in mono_class_layout_fields ().
4494 */
4498 }
4499 }
4503 inflated_classes ++;
4509 }
4511 /*
4512 * LOCKING: Acquires the loader lock.
4513 */
4514 MonoClass *
4515 mono_class_from_generic_parameter (MonoGenericParam *param, MonoImage *image, gboolean is_mvar)
4516 {
4525 }
4533 // FIXME: 'klass' should not be null
4534 // But, monodis creates GenericContainers without associating a owner to it
4536 }
4537 }
4539 /* FIXME: */
4551 }
4556 ;
4561 pos++;
4564 else
4572 }
4588 guint32 owner;
4596 i = mono_metadata_get_generic_param_row (image, param->owner->owner.klass->type_token, &owner);
4604 }
4609 }
4610 }
4623 }
4625 MonoClass *
4627 {
4644 }
4660 /* Can pointers get boxed? */
4678 }
4682 {
4686 /* FIXME: These should be allocate from a mempool as well, but which one ? */
4696 }
4707 result->flags = TYPE_ATTRIBUTE_CLASS; /* | (el_class->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK); */
4708 /* Can pointers get boxed? */
4727 }
4729 MonoClass *
4731 {
4789 }
4792 }
4794 /**
4795 * mono_type_retrieve_from_typespec
4796 * @image: context where the image is created
4797 * @type_spec: typespec token
4798 * @context: the generic context used to evaluate generic instantiations in
4799 */
4801 mono_type_retrieve_from_typespec (MonoImage *image, guint32 type_spec, MonoGenericContext *context, gboolean *did_inflate)
4802 {
4811 }
4812 }
4814 }
4816 /**
4817 * mono_class_create_from_typespec
4818 * @image: context where the image is created
4819 * @type_spec: typespec token
4820 * @context: the generic context used to evaluate generic instantiations in
4821 */
4823 mono_class_create_from_typespec (MonoImage *image, guint32 type_spec, MonoGenericContext *context)
4824 {
4834 }
4836 /**
4837 * mono_bounded_array_class_get:
4838 * @element_class: element class
4839 * @rank: the dimension of the array class
4840 * @bounded: whenever the array has non-zero bounds
4841 *
4842 * Returns: a class object describing the array with element type @element_type and
4843 * dimension @rank.
4844 */
4845 MonoClass *
4847 {
4859 /* bounded only matters for one-dimensional arrays */
4865 /*
4866 * This case is very frequent not just during compilation because of calls
4867 * from mono_class_from_mono_type (), mono_array_new (),
4868 * Array:CreateInstance (), etc, so use a separate cache + a separate lock.
4869 */
4888 if ((class->rank == rank) && (class->byval_arg.type == (((rank > 1) || bounded) ? MONO_TYPE_ARRAY : MONO_TYPE_SZARRAY))) {
4891 }
4892 }
4893 }
4894 }
4896 /* for the building corlib use System.Array from it */
4897 if (image->assembly && image->assembly->dynamic && image->assembly_name && strcmp (image->assembly_name, "mscorlib") == 0) {
4904 }
4928 /* all arrays are marked serializable and sealed, bug #42779 */
4938 }
4939 /* element_size -1 is ok as this is not an instantitable type*/
4950 class->has_references = MONO_TYPE_IS_REFERENCE (&eclass->byval_arg) || eclass->has_references? TRUE: FALSE;
4956 else
4967 /* FIXME: complete.... */
4971 }
4976 }
4986 /* Someone got in before us */
4988 else
4994 }
5001 }
5003 /**
5004 * mono_array_class_get:
5005 * @element_class: element class
5006 * @rank: the dimension of the array class
5007 *
5008 * Returns: a class object describing the array with element type @element_type and
5009 * dimension @rank.
5010 */
5011 MonoClass *
5013 {
5015 }
5017 /**
5018 * mono_class_instance_size:
5019 * @klass: a class
5020 *
5021 * Returns: the size of an object instance
5022 */
5023 gint32
5025 {
5030 }
5032 /**
5033 * mono_class_min_align:
5034 * @klass: a class
5035 *
5036 * Returns: minimm alignment requirements
5037 */
5038 gint32
5040 {
5045 }
5047 /**
5048 * mono_class_value_size:
5049 * @klass: a class
5050 *
5051 * This function is used for value types, and return the
5052 * space and the alignment to store that kind of value object.
5053 *
5054 * Returns: the size of a value of kind @klass
5055 */
5056 gint32
5058 {
5059 gint32 size;
5061 /* fixme: check disable, because we still have external revereces to
5062 * mscorlib and Dummy Objects
5063 */
5064 /*g_assert (klass->valuetype);*/
5072 }
5074 /**
5075 * mono_class_data_size:
5076 * @klass: a class
5077 *
5078 * Returns: the size of the static class data
5079 */
5080 gint32
5082 {
5086 /* in arrays, sizes.class_size is unioned with element_size
5087 * and arrays have no static fields
5088 */
5092 }
5094 /*
5095 * Auxiliary routine to mono_class_get_field
5096 *
5097 * Takes a field index instead of a field token.
5098 */
5101 {
5106 /*
5107 * class->field.first points to the FieldPtr table, while idx points into the
5108 * Field table, so we have to do a search.
5109 */
5110 const char *name = mono_metadata_string_heap (class->image, mono_metadata_decode_row_col (&class->image->tables [MONO_TABLE_FIELD], idx, MONO_FIELD_NAME));
5121 }
5122 }
5123 }
5125 }
5127 }
5129 /**
5130 * mono_class_get_field:
5131 * @class: the class to lookup the field.
5132 * @field_token: the field token
5133 *
5134 * Returns: A MonoClassField representing the type and offset of
5135 * the field, or a NULL value if the field does not belong to this
5136 * class.
5137 */
5138 MonoClassField *
5140 {
5146 }
5148 /**
5149 * mono_class_get_field_from_name:
5150 * @klass: the class to lookup the field.
5151 * @name: the field name
5152 *
5153 * Search the class @klass and it's parents for a field with the name @name.
5154 *
5155 * Returns: the MonoClassField pointer of the named field or NULL
5156 */
5157 MonoClassField *
5159 {
5167 }
5169 }
5171 }
5173 /**
5174 * mono_class_get_field_token:
5175 * @field: the field we need the token of
5176 *
5177 * Get the token of a field. Note that the tokesn is only valid for the image
5178 * the field was loaded from. Don't use this function for fields in dynamic types.
5179 *
5180 * Returns: the token representing the field in the image it was loaded from.
5181 */
5182 guint32
5184 {
5197 }
5198 }
5200 }
5204 }
5206 static int
5208 {
5214 }
5216 /*
5217 * mono_class_get_field_default_value:
5218 *
5219 * Return the default value of the field as a pointer into the metadata blob.
5220 */
5223 {
5224 guint32 cindex;
5235 klass->ext->field_def_values = mono_image_alloc0 (klass->image, sizeof (MonoFieldDefaultValue) * klass->field.count);
5237 }
5242 cindex = mono_metadata_get_constant_index (field->parent->image, mono_class_get_field_token (field), 0);
5246 mono_metadata_decode_row (&field->parent->image->tables [MONO_TABLE_CONSTANT], cindex - 1, constant_cols, MONO_CONSTANT_SIZE);
5248 klass->ext->field_def_values [field_index].data = (gpointer)mono_metadata_blob_heap (field->parent->image, constant_cols [MONO_CONSTANT_VALUE]);
5249 }
5253 }
5255 guint32
5257 {
5266 }
5267 }
5269 }
5273 }
5275 MonoProperty*
5277 {
5284 }
5286 }
5288 }
5290 guint32
5292 {
5302 i ++;
5303 }
5305 }
5309 }
5313 {
5329 else
5331 }
5342 else
5344 }
5350 }
5353 }
5357 {
5366 MonoAssemblyName aname;
5369 guint32 idx;
5376 /* FIXME: */
5379 /* FIXME: */
5382 /* FIXME: */
5389 }
5391 }
5393 /* FIXME: */
5397 }
5400 }
5402 /**
5403 * mono_class_get_full:
5404 * @image: the image where the class resides
5405 * @type_token: the token for the class
5406 * @context: the generic context used to evaluate generic instantiations in
5407 *
5408 * Returns: the MonoClass that represents @type_token in @image
5409 */
5410 MonoClass *
5412 {
5418 if (table != MONO_TABLE_TYPEDEF && table != MONO_TABLE_TYPEREF && table != MONO_TABLE_TYPESPEC) {
5421 }
5423 }
5438 }
5444 }
5447 }
5450 /**
5451 * mono_type_get_full:
5452 * @image: the image where the type resides
5453 * @type_token: the token for the type
5454 * @context: the generic context used to evaluate generic instantiations in
5455 *
5456 * This functions exists to fullfill the fact that sometimes it's desirable to have access to the
5457 *
5458 * Returns: the MonoType that represents @type_token in @image
5459 */
5460 MonoType *
5462 {
5466 //FIXME: this will not fix the very issue for which mono_type_get_full exists -but how to do it then?
5473 }
5483 }
5488 /* FIXME: This is a workaround fo the fact that a typespec token sometimes reference to the generic type definition.
5489 * A MonoClass::byval_arg of a generic type definion has type CLASS.
5490 * Some parts of mono create a GENERICINST to reference a generic type definition and this generates confict with byval_arg.
5491 *
5492 * The long term solution is to chaise this places and make then set MonoType::type correctly.
5493 * */
5496 else
5498 }
5500 }
5503 MonoClass *
5505 {
5507 }
5509 /**
5510 * mono_image_init_name_cache:
5511 *
5512 * Initializes the class name cache stored in image->name_cache.
5513 *
5514 * LOCKING: Acquires the loader lock.
5515 */
5516 void
5518 {
5533 }
5535 /* Temporary hash table to avoid lookups in the nspace_table */
5541 /*
5542 * Nested types are accessed from the nesting name. We use the fact that nested types use different visibility flags
5543 * than toplevel types, thus avoiding the need to grovel through the NESTED_TYPE table
5544 */
5556 nspace_table);
5557 }
5559 }
5561 /* Load type names from EXPORTEDTYPES table */
5562 {
5578 nspace_table);
5579 }
5580 g_hash_table_insert (nspace_table, (char *) name, GUINT_TO_POINTER (mono_metadata_make_token (MONO_TABLE_EXPORTEDTYPE, i + 1)));
5581 }
5582 }
5587 }
5589 void
5592 {
5605 }
5609 }
5612 gconstpointer key;
5613 gpointer value;
5616 static void
5618 {
5624 }
5626 /**
5627 * mono_class_from_name_case:
5628 * @image: The MonoImage where the type is looked up in
5629 * @name_space: the type namespace
5630 * @name: the type short name.
5631 *
5632 * Obtains a MonoClass with a given namespace and a given name which
5633 * is located in the given MonoImage. The namespace and name
5634 * lookups are case insensitive.
5635 */
5636 MonoClass *
5638 {
5647 FindUserData user_data;
5668 }
5674 else
5677 }
5679 /* add a cache if needed */
5683 /*
5684 * Nested types are accessed from the nesting name. We use the fact that nested types use different visibility flags
5685 * than toplevel types, thus avoiding the need to grovel through the NESTED_TYPE table
5686 */
5693 }
5695 }
5699 {
5706 s++;
5707 }
5714 }
5715 }
5717 }
5721 {
5727 /*
5728 * The EXPORTEDTYPES table only contains public types, so have to search the
5729 * modules as well.
5730 * Note: image->modules contains the contents of the MODULEREF table, while
5731 * the real module list is in the FILE table.
5732 */
5744 }
5745 }
5748 }
5750 /**
5751 * mono_class_from_name:
5752 * @image: The MonoImage where the type is looked up in
5753 * @name_space: the type namespace
5754 * @name: the type short name.
5755 *
5756 * Obtains a MonoClass with a given namespace and a given name which
5757 * is located in the given MonoImage.
5758 */
5759 MonoClass *
5761 {
5779 }
5788 else
5790 }
5791 }
5806 /* Search modules as well */
5813 }
5814 }
5820 }
5845 guint32 assembly_idx;
5855 else
5856 /* FIXME: Cycle detection */
5860 }
5861 }
5869 }
5871 gboolean
5873 gboolean check_interfaces)
5874 {
5876 if (check_interfaces && MONO_CLASS_IS_INTERFACE (klassc) && !MONO_CLASS_IS_INTERFACE (klass)) {
5879 } else if (check_interfaces && MONO_CLASS_IS_INTERFACE (klassc) && MONO_CLASS_IS_INTERFACE (klass)) {
5886 }
5890 }
5892 /*
5893 * MS.NET thinks interfaces are a subclass of Object, so we think it as
5894 * well.
5895 */
5900 }
5902 static gboolean
5904 {
5918 }
5920 /**
5921 * mono_class_is_assignable_from:
5922 * @klass: the class to be assigned to
5923 * @oklass: the source class
5924 *
5925 * Return: true if an instance of object oklass can be assigned to an
5926 * instance of object @klass
5927 */
5928 gboolean
5930 {
5944 /* interface_offsets might not be set for dynamic classes */
5946 /*
5947 * oklass might be a generic type parameter but they have
5948 * interface_offsets set.
5949 */
5952 /* Happens with generic instances of not-yet created dynamic types */
5964 /*
5965 * Check whenever the generic definition of oklass implements the
5966 * generic definition of klass. The IMPLEMENTS_INTERFACE stuff is not usable
5967 * here since the relevant tables are not set up.
5968 */
5970 if ((container_class2->interfaces_packed [i] == container_class1) || (container_class2->interfaces_packed [i]->generic_class && (container_class2->interfaces_packed [i]->generic_class->container_class == container_class1)))
5980 MonoClass *param1_class = mono_class_from_mono_type (klass->generic_class->context.class_inst->type_argv [i]);
5981 MonoClass *param2_class = mono_class_from_mono_type (oklass->generic_class->context.class_inst->type_argv [i]);
5986 }
5987 /*
5988 * The _VARIANT and _COVARIANT constants should read _COVARIANT and
5989 * _CONTRAVARIANT, but they are in a public header so we can't fix it.
5990 */
5992 if ((container->type_params [i].flags & MONO_GEN_PARAM_VARIANT) && mono_class_is_assignable_from (param1_class, param2_class))
5993 ;
5994 else if (((container->type_params [i].flags & MONO_GEN_PARAM_COVARIANT) && mono_class_is_assignable_from (param2_class, param1_class)))
5995 ;
5999 }
6000 }
6001 }
6005 }
6006 }
6007 }
6014 /* vectors vs. one dimensional arrays */
6021 /*
6022 * a is b does not imply a[] is b[] when a is a valuetype, and
6023 * b is a reference type.
6024 */
6031 }
6037 else
6043 }
6045 /**
6046 * mono_class_get_cctor:
6047 * @klass: A MonoClass pointer
6048 *
6049 * Returns: the static constructor of @klass if it exists, NULL otherwise.
6050 */
6051 MonoMethod*
6053 {
6054 MonoCachedClassInfo cached_info;
6063 return mono_class_get_inflated_method (klass, mono_class_get_cctor (klass->generic_class->container_class));
6065 return mono_class_get_method_from_name_flags (klass, ".cctor", -1, METHOD_ATTRIBUTE_SPECIAL_NAME);
6066 }
6068 /**
6069 * mono_class_get_finalizer:
6070 * @klass: The MonoClass pointer
6071 *
6072 * Returns: the finalizer method of @klass if it exists, NULL otherwise.
6073 */
6074 MonoMethod*
6076 {
6077 MonoCachedClassInfo cached_info;
6089 }
6090 }
6092 /**
6093 * mono_class_needs_cctor_run:
6094 * @klass: the MonoClass pointer
6095 * @caller: a MonoMethod describing the caller
6096 *
6097 * Determines whenever the class has a static constructor and whenever it
6098 * needs to be called when executing CALLER.
6099 */
6100 gboolean
6102 {
6108 else
6110 }
6112 /**
6113 * mono_class_array_element_size:
6114 * @klass:
6115 *
6116 * Returns: the number of bytes an element of type @klass
6117 * uses when stored into an array.
6118 */
6119 gint32
6121 {
6124 handle_enum:
6158 }
6165 }
6167 }
6169 /**
6170 * mono_array_element_size:
6171 * @ac: pointer to a #MonoArrayClass
6172 *
6173 * Returns: the size of single array element.
6174 */
6175 gint32
6177 {
6180 }
6182 gpointer
6185 {
6188 gpointer obj = mono_lookup_dynamic_token_class (image, token, TRUE, &tmp_handle_class, context);
6196 else
6198 }
6211 /* We return a MonoType* as handle */
6213 }
6224 }
6232 }
6236 mono_metadata_decode_row (&image->tables [MONO_TABLE_MEMBERREF], mono_metadata_token_index (token) - 1, cols, MONO_MEMBERREF_SIZE);
6252 }
6253 }
6257 }
6259 }
6261 /**
6262 * This function might need to call runtime functions so it can't be part
6263 * of the metadata library.
6264 */
6267 void
6269 {
6271 }
6273 gpointer
6275 {
6279 }
6281 gpointer
6282 mono_lookup_dynamic_token_class (MonoImage *image, guint32 token, gboolean valid_token, MonoClass **handle_class, MonoGenericContext *context)
6283 {
6285 }
6289 void
6291 {
6293 }
6295 static gboolean
6297 {
6300 else
6302 }
6304 void
6306 {
6308 }
6310 MonoImage*
6312 {
6314 }
6316 /**
6317 * mono_class_get_element_class:
6318 * @klass: the MonoClass to act on
6319 *
6320 * Returns: the element class of an array or an enumeration.
6321 */
6322 MonoClass*
6324 {
6326 }
6328 /**
6329 * mono_class_is_valuetype:
6330 * @klass: the MonoClass to act on
6331 *
6332 * Returns: true if the MonoClass represents a ValueType.
6333 */
6334 gboolean
6336 {
6338 }
6340 /**
6341 * mono_class_is_enum:
6342 * @klass: the MonoClass to act on
6343 *
6344 * Returns: true if the MonoClass represents an enumeration.
6345 */
6346 gboolean
6348 {
6350 }
6352 /**
6353 * mono_class_enum_basetype:
6354 * @klass: the MonoClass to act on
6355 *
6356 * Returns: the underlying type representation for an enumeration.
6357 */
6358 MonoType*
6360 {
6362 /* SRE */
6364 else
6366 }
6368 /**
6369 * mono_class_get_parent
6370 * @klass: the MonoClass to act on
6371 *
6372 * Returns: the parent class for this class.
6373 */
6374 MonoClass*
6376 {
6378 }
6380 /**
6381 * mono_class_get_nesting_type;
6382 * @klass: the MonoClass to act on
6383 *
6384 * Returns: the container type where this type is nested or NULL if this type is not a nested type.
6385 */
6386 MonoClass*
6388 {
6390 }
6392 /**
6393 * mono_class_get_rank:
6394 * @klass: the MonoClass to act on
6395 *
6396 * Returns: the rank for the array (the number of dimensions).
6397 */
6398 int
6400 {
6402 }
6404 /**
6405 * mono_class_get_flags:
6406 * @klass: the MonoClass to act on
6407 *
6408 * The type flags from the TypeDef table from the metadata.
6409 * see the TYPE_ATTRIBUTE_* definitions on tabledefs.h for the
6410 * different values.
6411 *
6412 * Returns: the flags from the TypeDef table.
6413 */
6414 guint32
6416 {
6418 }
6420 /**
6421 * mono_class_get_name
6422 * @klass: the MonoClass to act on
6423 *
6424 * Returns: the name of the class.
6425 */
6428 {
6430 }
6432 /**
6433 * mono_class_get_namespace:
6434 * @klass: the MonoClass to act on
6435 *
6436 * Returns: the namespace of the class.
6437 */
6440 {
6442 }
6444 /**
6445 * mono_class_get_type:
6446 * @klass: the MonoClass to act on
6447 *
6448 * This method returns the internal Type representation for the class.
6449 *
6450 * Returns: the MonoType from the class.
6451 */
6452 MonoType*
6454 {
6456 }
6458 /**
6459 * mono_class_get_type_token
6460 * @klass: the MonoClass to act on
6461 *
6462 * This method returns type token for the class.
6463 *
6464 * Returns: the type token for the class.
6465 */
6466 guint32
6468 {
6470 }
6472 /**
6473 * mono_class_get_byref_type:
6474 * @klass: the MonoClass to act on
6475 *
6476 *
6477 */
6478 MonoType*
6480 {
6482 }
6484 /**
6485 * mono_class_num_fields:
6486 * @klass: the MonoClass to act on
6487 *
6488 * Returns: the number of static and instance fields in the class.
6489 */
6490 int
6492 {
6494 }
6496 /**
6497 * mono_class_num_methods:
6498 * @klass: the MonoClass to act on
6499 *
6500 * Returns: the number of methods in the class.
6501 */
6502 int
6504 {
6506 }
6508 /**
6509 * mono_class_num_properties
6510 * @klass: the MonoClass to act on
6511 *
6512 * Returns: the number of properties in the class.
6513 */
6514 int
6516 {
6520 }
6522 /**
6523 * mono_class_num_events:
6524 * @klass: the MonoClass to act on
6525 *
6526 * Returns: the number of events in the class.
6527 */
6528 int
6530 {
6534 }
6536 /**
6537 * mono_class_get_fields:
6538 * @klass: the MonoClass to act on
6539 *
6540 * This routine is an iterator routine for retrieving the fields in a class.
6541 *
6542 * You must pass a gpointer that points to zero and is treated as an opaque handle to
6543 * iterate over all of the elements. When no more values are
6544 * available, the return value is NULL.
6545 *
6546 * Returns: a @MonoClassField* on each iteration, or NULL when no more fields are available.
6547 */
6548 MonoClassField*
6550 {
6558 /* start from the first */
6562 /* no fields */
6564 }
6565 }
6567 field++;
6570 }
6572 }
6574 /**
6575 * mono_class_get_methods
6576 * @klass: the MonoClass to act on
6577 *
6578 * This routine is an iterator routine for retrieving the fields in a class.
6579 *
6580 * You must pass a gpointer that points to zero and is treated as an opaque handle to
6581 * iterate over all of the elements. When no more values are
6582 * available, the return value is NULL.
6583 *
6584 * Returns: a MonoMethod on each iteration or NULL when no more methods are available.
6585 */
6586 MonoMethod*
6588 {
6596 /* start from the first */
6601 /* no method */
6603 }
6604 }
6606 method++;
6610 }
6612 }
6614 /*
6615 * mono_class_get_virtual_methods:
6616 *
6617 * Iterate over the virtual methods of KLASS.
6618 *
6619 * LOCKING: Assumes the loader lock is held (because of the klass->methods check).
6620 */
6623 {
6627 if (klass->methods || !MONO_CLASS_HAS_STATIC_METADATA (klass) || mono_debug_using_mono_debugger ()) {
6630 /* start from the first */
6634 method++;
6635 }
6639 method ++;
6640 }
6646 }
6648 /* Search directly in metadata to avoid calling setup_methods () */
6656 }
6661 /* class->method.first points into the methodptr table */
6662 mono_metadata_decode_table_row (klass->image, MONO_TABLE_METHOD, klass->method.first + i, cols, MONO_METHOD_SIZE);
6666 }
6669 res = mono_get_method (klass->image, MONO_TOKEN_METHOD_DEF | (klass->method.first + i + 1), klass);
6670 /* Add 1 here so the if (*iter) check fails */
6675 }
6676 }
6677 }
6679 /**
6680 * mono_class_get_properties:
6681 * @klass: the MonoClass to act on
6682 *
6683 * This routine is an iterator routine for retrieving the properties in a class.
6684 *
6685 * You must pass a gpointer that points to zero and is treated as an opaque handle to
6686 * iterate over all of the elements. When no more values are
6687 * available, the return value is NULL.
6688 *
6689 * Returns: a @MonoProperty* on each invocation, or NULL when no more are available.
6690 */
6691 MonoProperty*
6693 {
6701 /* start from the first */
6705 /* no fields */
6707 }
6708 }
6710 property++;
6713 }
6715 }
6717 /**
6718 * mono_class_get_events:
6719 * @klass: the MonoClass to act on
6720 *
6721 * This routine is an iterator routine for retrieving the properties in a class.
6722 *
6723 * You must pass a gpointer that points to zero and is treated as an opaque handle to
6724 * iterate over all of the elements. When no more values are
6725 * available, the return value is NULL.
6726 *
6727 * Returns: a @MonoEvent* on each invocation, or NULL when no more are available.
6728 */
6729 MonoEvent*
6731 {
6739 /* start from the first */
6743 /* no fields */
6745 }
6746 }
6748 event++;
6751 }
6753 }
6755 /**
6756 * mono_class_get_interfaces
6757 * @klass: the MonoClass to act on
6758 *
6759 * This routine is an iterator routine for retrieving the interfaces implemented by this class.
6760 *
6761 * You must pass a gpointer that points to zero and is treated as an opaque handle to
6762 * iterate over all of the elements. When no more values are
6763 * available, the return value is NULL.
6764 *
6765 * Returns: a @Monoclass* on each invocation, or NULL when no more are available.
6766 */
6767 MonoClass*
6769 {
6778 /* start from the first */
6783 /* no interface */
6785 }
6786 }
6788 iface++;
6792 }
6794 }
6796 /**
6797 * mono_class_get_nested_types
6798 * @klass: the MonoClass to act on
6799 *
6800 * This routine is an iterator routine for retrieving the nested types of a class.
6801 * This works only if @klass is non-generic, or a generic type definition.
6802 *
6803 * You must pass a gpointer that points to zero and is treated as an opaque handle to
6804 * iterate over all of the elements. When no more values are
6805 * available, the return value is NULL.
6806 *
6807 * Returns: a @Monoclass* on each invocation, or NULL when no more are available.
6808 */
6809 MonoClass*
6811 {
6828 mono_metadata_decode_row (&klass->image->tables [MONO_TABLE_NESTEDCLASS], i - 1, cols, MONO_NESTED_CLASS_SIZE);
6829 nclass = mono_class_create_from_typedef (klass->image, MONO_TOKEN_TYPE_DEF | cols [MONO_NESTED_CLASS_NESTED]);
6831 klass->ext->nested_classes = g_list_prepend_image (klass->image, klass->ext->nested_classes, nclass);
6834 }
6835 }
6839 }
6842 /* start from the first */
6847 /* no nested types */
6849 }
6850 }
6856 }
6858 }
6860 /**
6861 * mono_field_get_name:
6862 * @field: the MonoClassField to act on
6863 *
6864 * Returns: the name of the field.
6865 */
6868 {
6870 }
6872 /**
6873 * mono_field_get_type:
6874 * @field: the MonoClassField to act on
6875 *
6876 * Returns: MonoType of the field.
6877 */
6878 MonoType*
6880 {
6882 }
6884 /**
6885 * mono_field_get_type:
6886 * @field: the MonoClassField to act on
6887 *
6888 * Returns: MonoClass where the field was defined.
6889 */
6890 MonoClass*
6892 {
6894 }
6896 /**
6897 * mono_field_get_flags;
6898 * @field: the MonoClassField to act on
6899 *
6900 * The metadata flags for a field are encoded using the
6901 * FIELD_ATTRIBUTE_* constants. See the tabledefs.h file for details.
6902 *
6903 * Returns: the flags for the field.
6904 */
6905 guint32
6907 {
6909 }
6911 /**
6912 * mono_field_get_offset;
6913 * @field: the MonoClassField to act on
6914 *
6915 * Returns: the field offset.
6916 */
6917 guint32
6919 {
6921 }
6925 {
6926 guint32 rva;
6936 klass->ext->field_def_values = mono_image_alloc0 (klass->image, sizeof (MonoFieldDefaultValue) * klass->field.count);
6938 }
6943 mono_metadata_field_info (field->parent->image, klass->field.first + field_index, NULL, &rva, NULL);
6945 g_warning ("field %s in %s should have RVA data, but hasn't", mono_field_get_name (field), field->parent->name);
6946 klass->ext->field_def_values [field_index].data = mono_image_rva_map (field->parent->image, rva);
6947 }
6950 }
6952 /**
6953 * mono_field_get_data;
6954 * @field: the MonoClassField to act on
6955 *
6956 * Returns: pointer to the metadata constant value or to the field
6957 * data if it has an RVA flag.
6958 */
6961 {
6963 MonoTypeEnum def_type;
6970 }
6971 }
6973 /**
6974 * mono_property_get_name:
6975 * @prop: the MonoProperty to act on
6976 *
6977 * Returns: the name of the property
6978 */
6981 {
6983 }
6985 /**
6986 * mono_property_get_set_method
6987 * @prop: the MonoProperty to act on.
6988 *
6989 * Returns: the setter method of the property (A MonoMethod)
6990 */
6991 MonoMethod*
6993 {
6995 }
6997 /**
6998 * mono_property_get_get_method
6999 * @prop: the MonoProperty to act on.
7000 *
7001 * Returns: the setter method of the property (A MonoMethod)
7002 */
7003 MonoMethod*
7005 {
7007 }
7009 /**
7010 * mono_property_get_parent:
7011 * @prop: the MonoProperty to act on.
7012 *
7013 * Returns: the MonoClass where the property was defined.
7014 */
7015 MonoClass*
7017 {
7019 }
7021 /**
7022 * mono_property_get_flags:
7023 * @prop: the MonoProperty to act on.
7024 *
7025 * The metadata flags for a property are encoded using the
7026 * PROPERTY_ATTRIBUTE_* constants. See the tabledefs.h file for details.
7027 *
7028 * Returns: the flags for the property.
7029 */
7030 guint32
7032 {
7034 }
7036 /**
7037 * mono_event_get_name:
7038 * @event: the MonoEvent to act on
7039 *
7040 * Returns: the name of the event.
7041 */
7044 {
7046 }
7048 /**
7049 * mono_event_get_add_method:
7050 * @event: The MonoEvent to act on.
7051 *
7052 * Returns: the @add' method for the event (a MonoMethod).
7053 */
7054 MonoMethod*
7056 {
7058 }
7060 /**
7061 * mono_event_get_remove_method:
7062 * @event: The MonoEvent to act on.
7063 *
7064 * Returns: the @remove method for the event (a MonoMethod).
7065 */
7066 MonoMethod*
7068 {
7070 }
7072 /**
7073 * mono_event_get_raise_method:
7074 * @event: The MonoEvent to act on.
7075 *
7076 * Returns: the @raise method for the event (a MonoMethod).
7077 */
7078 MonoMethod*
7080 {
7082 }
7084 /**
7085 * mono_event_get_parent:
7086 * @event: the MonoEvent to act on.
7087 *
7088 * Returns: the MonoClass where the event is defined.
7089 */
7090 MonoClass*
7092 {
7094 }
7096 /**
7097 * mono_event_get_flags
7098 * @event: the MonoEvent to act on.
7099 *
7100 * The metadata flags for an event are encoded using the
7101 * EVENT_* constants. See the tabledefs.h file for details.
7102 *
7103 * Returns: the flags for the event.
7104 */
7105 guint32
7107 {
7109 }
7111 /**
7112 * mono_class_get_method_from_name:
7113 * @klass: where to look for the method
7114 * @name_space: name of the method
7115 * @param_count: number of parameters. -1 for any number.
7116 *
7117 * Obtains a MonoMethod with a given name and number of parameters.
7118 * It only works if there are no multiple signatures for any given method name.
7119 */
7120 MonoMethod *
7122 {
7124 }
7128 {
7132 /* Search directly in the metadata to avoid calling setup_methods () */
7137 /* class->method.first points into the methodptr table */
7138 mono_metadata_decode_table_row (klass->image, MONO_TABLE_METHOD, klass->method.first + i, cols, MONO_METHOD_SIZE);
7141 method = mono_get_method (klass->image, MONO_TOKEN_METHOD_DEF | (klass->method.first + i + 1), klass);
7145 }
7146 }
7147 }
7150 }
7152 /**
7153 * mono_class_get_method_from_name_flags:
7154 * @klass: where to look for the method
7155 * @name_space: name of the method
7156 * @param_count: number of parameters. -1 for any number.
7157 * @flags: flags which must be set in the method
7158 *
7159 * Obtains a MonoMethod with a given name and number of parameters.
7160 * It only works if there are no multiple signatures for any given method name.
7161 */
7162 MonoMethod *
7163 mono_class_get_method_from_name_flags (MonoClass *klass, const char *name, int param_count, int flags)
7164 {
7171 res = mono_class_get_method_from_name_flags (klass->generic_class->container_class, name, param_count, flags);
7175 }
7188 }
7189 }
7190 }
7193 }
7196 }
7198 /**
7199 * mono_class_set_failure:
7200 * @klass: class in which the failure was detected
7201 * @ex_type: the kind of exception/error to be thrown (later)
7202 * @ex_data: exception data (specific to each type of exception/error)
7203 *
7204 * Keep a detected failure informations in the class for later processing.
7205 * Note that only the first failure is kept.
7206 *
7207 * LOCKING: Acquires the loader lock.
7208 */
7209 gboolean
7211 {
7222 }
7224 /*
7225 * mono_class_get_exception_data:
7226 *
7227 * Return the exception_data property of KLASS.
7228 *
7229 * LOCKING: Acquires the loader lock.
7230 */
7231 gpointer
7233 {
7235 }
7237 /**
7238 * mono_classes_init:
7239 *
7240 * Initialize the resources used by this module.
7241 */
7242 void
7244 {
7255 }
7257 /**
7258 * mono_classes_cleanup:
7259 *
7260 * Free the resources used by this module.
7261 */
7262 void
7264 {
7267 }
7269 /**
7270 * mono_class_get_exception_for_failure:
7271 * @klass: class in which the failure was detected
7272 *
7273 * Return a constructed MonoException than the caller can then throw
7274 * using mono_raise_exception - or NULL if no failure is present (or
7275 * doesn't result in an exception).
7276 */
7277 MonoException*
7279 {
7287 guint32 error = (method) ? MONO_METADATA_INHERITANCEDEMAND_METHOD : MONO_METADATA_INHERITANCEDEMAND_CLASS;
7298 }
7303 char *astr = klass->image->assembly? mono_stringify_assembly_name (&klass->image->assembly->aname): NULL;
7309 }
7315 }
7321 }
7328 ex = mono_get_exception_file_not_found2 (msg, mono_string_new (mono_domain_get (), assembly_name));
7333 }
7336 }
7345 }
7347 /* TODO - handle other class related failures */
7349 }
7350 }
7351 }
7353 static gboolean
7355 {
7364 }
7366 MonoClass *
7368 {
7370 }
7372 /*
7373 * Check if @klass is a subtype of @parent ignoring generic instantiations.
7374 *
7375 * Generic instantiations are ignored for all super types of @klass.
7376 *
7377 * Visibility checks ignoring generic instantiations.
7378 */
7379 gboolean
7381 {
7389 }
7391 }
7392 /*
7393 * Subtype can only access parent members with family protection if the site object
7394 * is subclass of Subtype. For example:
7395 * class A { protected int x; }
7396 * class B : A {
7397 * void valid_access () {
7398 * B b;
7399 * b.x = 0;
7400 * }
7401 * void invalid_access () {
7402 * A a;
7403 * a.x = 0;
7404 * }
7405 * }
7406 * */
7407 static gboolean
7408 is_valid_family_access (MonoClass *access_klass, MonoClass *member_klass, MonoClass *context_klass)
7409 {
7415 /*if access_klass is not member_klass context_klass must be type compat*/
7416 if (access_klass != member_klass && !mono_class_has_parent_and_ignore_generics (context_klass, access_klass))
7419 }
7421 static gboolean
7423 {
7432 /* Be conservative with checks */
7440 if (!mono_public_tokens_are_equal (friend->public_key_token, accessing->aname.public_key_token))
7442 }
7444 }
7446 }
7448 /*
7449 * If klass is a generic type or if it is derived from a generic type, return the
7450 * MonoClass of the generic definition
7451 * Returns NULL if not found
7452 */
7455 {
7460 }
7462 }
7464 static gboolean
7466 {
7474 }
7476 }
7478 static gboolean
7480 {
7483 if (member_klass->generic_class && !can_access_instantiation (access_klass, member_klass->generic_class->context.class_inst))
7486 if (is_nesting_type (access_klass, member_klass) || (access_klass->nested_in && is_nesting_type (access_klass->nested_in, member_klass)))
7512 return can_access_internals (access_klass->image->assembly, member_klass->nested_in->image->assembly) &&
7516 return can_access_internals (access_klass->image->assembly, member_klass->nested_in->image->assembly) ||
7518 }
7520 }
7522 /* FIXME: check visibility of type, too */
7523 static gboolean
7524 can_access_member (MonoClass *access_klass, MonoClass *member_klass, MonoClass* context_klass, int access_level)
7525 {
7534 else
7539 }
7541 /* Partition I 8.5.3.2 */
7542 /* the access level values are the same for fields and methods */
7545 /* same compilation unit */
7566 }
7568 }
7570 gboolean
7572 {
7573 /* FIXME: check all overlapping fields */
7574 int can = can_access_member (method->klass, field->parent, NULL, field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK);
7578 can = can_access_member (nested, field->parent, NULL, field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK);
7582 }
7583 }
7585 }
7587 gboolean
7589 {
7590 int can = can_access_member (method->klass, called->klass, NULL, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
7594 can = can_access_member (nested, called->klass, NULL, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
7598 }
7599 }
7600 /*
7601 * FIXME:
7602 * with generics calls to explicit interface implementations can be expressed
7603 * directly: the method is private, but we must allow it. This may be opening
7604 * a hole or the generics code should handle this differently.
7605 * Maybe just ensure the interface type is public.
7606 */
7610 }
7612 /*
7613 * mono_method_can_access_method_with_context:
7614 * @method: The caller method
7615 * @called: The called method
7616 * @context_klass:TThe static type on stack of the owner @called object used
7617 *
7618 * This function must be used with instance calls, as they have more strict family accessibility.
7619 * It can be used with static mehthod, but context_klass should be NULL.
7620 *
7621 * Returns: TRUE if caller have proper visibility and acessibility to @called
7622 */
7623 gboolean
7624 mono_method_can_access_method_full (MonoMethod *method, MonoMethod *called, MonoClass *context_klass)
7625 {
7628 int can = can_access_member (access_class, member_class, context_klass, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
7632 can = can_access_member (nested, member_class, context_klass, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
7636 }
7637 }
7642 if (!can_access_type (access_class, member_class) && (!access_class->nested_in || !can_access_type (access_class->nested_in, member_class)))
7647 if (infl->context.method_inst && !can_access_instantiation (access_class, infl->context.method_inst))
7649 }
7652 }
7655 /*
7656 * mono_method_can_access_method_with_context:
7657 * @method: The caller method
7658 * @field: The accessed field
7659 * @context_klass: The static type on stack of the owner @field object used
7660 *
7661 * This function must be used with instance fields, as they have more strict family accessibility.
7662 * It can be used with static fields, but context_klass should be NULL.
7663 *
7664 * Returns: TRUE if caller have proper visibility and acessibility to @field
7665 */
7666 gboolean
7667 mono_method_can_access_field_full (MonoMethod *method, MonoClassField *field, MonoClass *context_klass)
7668 {
7671 /* FIXME: check all overlapping fields */
7672 int can = can_access_member (access_class, member_class, context_klass, field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK);
7676 can = can_access_member (nested, member_class, context_klass, field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK);
7680 }
7681 }
7686 if (!can_access_type (access_class, member_class) && (!access_class->nested_in || !can_access_type (access_class->nested_in, member_class)))
7689 }
7691 /**
7692 * mono_type_is_valid_enum_basetype:
7693 * @type: The MonoType to check
7694 *
7695 * Returns: TRUE if the type can be used as the basetype of an enum
7696 */
7712 }
7714 }
7716 /**
7717 * mono_class_is_valid_enum:
7718 * @klass: An enum class to be validated
7719 *
7720 * This method verify the required properties an enum should have.
7721 *
7722 * Returns: TRUE if the informed enum class is valid
7723 *
7724 * FIXME: TypeBuilder enums are allowed to implement interfaces, but since they cannot have methods, only empty interfaces are possible
7725 * FIXME: enum types are not allowed to have a cctor, but mono_reflection_create_runtime_class sets has_cctor to 1 for all types
7726 * FIXME: TypeBuilder enums can have any kind of static fields, but the spec is very explicit about that (P II 14.3)
7727 */
7734 /* we cannot test against mono_defaults.enum_class, or mcs won't be able to compile the System namespace*/
7735 if (!klass->parent || strcmp (klass->parent->name, "Enum") || strcmp (klass->parent->name_space, "System") ) {
7737 }
7749 }
7750 }
7759 }
7761 gboolean
7763 {
7764 return gklass->context.class_inst == gklass->container_class->generic_container->context.class_inst;
7765 }
7767 /*
7768 * mono_class_generic_sharing_enabled:
7769 * @class: a class
7770 *
7771 * Returns whether generic sharing is enabled for class.
7772 *
7773 * This is a stop-gap measure to slowly introduce generic sharing
7774 * until we have all the issues sorted out, at which time this
7775 * function will disappear and generic sharing will always be enabled.
7776 */
7777 gboolean
7779 {
7780 #if defined(__i386__) || defined(__x86_64__) || defined(__arm__) || defined(__mono_ppc__)
7782 #else
7783 /* Not supported by the JIT backends */
7785 #endif
7794 else
7806 else
7808 }
7814 }
7831 }
7832 }
7834 /*
7835 * mono_class_setup_interface_id:
7836 *
7837 * Initializes MonoClass::interface_id if required.
7838 *
7839 * LOCKING: Acquires the loader lock.
7840 */
7841 void
7843 {
7848 }
7850 /*
7851 * mono_class_alloc_ext:
7852 *
7853 * Allocate klass->ext if not already done.
7854 * LOCKING: Assumes the loader lock is held.
7855 */
7856 void
7858 {
7864 }
7866 }
7867 }
7869 /*
7870 * mono_class_setup_interfaces:
7871 *
7872 * Initialize class->interfaces/interfaces_count.
7873 * LOCKING: Acquires the loader lock.
7874 */
7875 void
7877 {
7888 }
7890 if (klass->rank == 1 && klass->byval_arg.type != MONO_TYPE_ARRAY && mono_defaults.generic_ilist_class) {
7893 /* generic IList, ICollection, IEnumerable */
7895 klass->interfaces = mono_image_alloc0 (klass->image, sizeof (MonoClass*) * klass->interface_count);
7906 klass->interfaces [i] = mono_class_inflate_generic_class (gklass->interfaces [i], mono_generic_class_get_context (klass->generic_class));
7907 }
7914 }