| blob | 62426966874791290ca888dc24d843534fc804d3 |
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 #if !HOST_WIN32
19 #include <mono/io-layer/atomic.h>
20 #endif
21 #include <mono/metadata/image.h>
22 #include <mono/metadata/assembly.h>
23 #include <mono/metadata/metadata.h>
24 #include <mono/metadata/metadata-internals.h>
25 #include <mono/metadata/profiler-private.h>
26 #include <mono/metadata/tabledefs.h>
27 #include <mono/metadata/tokentype.h>
28 #include <mono/metadata/class-internals.h>
29 #include <mono/metadata/object.h>
30 #include <mono/metadata/appdomain.h>
31 #include <mono/metadata/mono-endian.h>
32 #include <mono/metadata/debug-helpers.h>
33 #include <mono/metadata/reflection.h>
34 #include <mono/metadata/exception.h>
35 #include <mono/metadata/security-manager.h>
36 #include <mono/metadata/security-core-clr.h>
37 #include <mono/metadata/attrdefs.h>
38 #include <mono/metadata/gc-internal.h>
39 #include <mono/metadata/verify-internals.h>
40 #include <mono/metadata/mono-debug.h>
41 #include <mono/utils/mono-counters.h>
42 #include <mono/utils/mono-string.h>
43 #include <mono/utils/mono-error-internals.h>
45 MonoStats mono_stats;
49 /*
50 * Controls whenever mono_class_init () constructs a generic vtable. This is TRUE by
51 * default to avoid breaking embedding apps, but set to FALSE by the runtime executable
52 * startup code.
53 */
56 /* Statistics */
60 /* Function supplied by the runtime to find classes by name using information from the AOT file */
66 static MonoMethod* find_method_in_metadata (MonoClass *klass, const char *name, int param_count, int flags);
68 static void setup_generic_array_ifaces (MonoClass *class, MonoClass *iface, MonoMethod **methods, int pos);
78 /*
79 * mono_class_from_typeref:
80 * @image: a MonoImage
81 * @type_token: a TypeRef token
82 *
83 * Creates the MonoClass* structure representing the type defined by
84 * the typeref token valid inside @image.
85 * Returns: the MonoClass* representing the typeref token, NULL ifcould
86 * not be loaded.
87 */
88 MonoClass *
90 {
93 guint32 idx;
108 /* a typedef in disguise */
124 }
133 /* Micro-optimization: don't scan the metadata tables if enclosing is already inited */
138 }
140 /* Don't call mono_class_init as we might've been called by it recursively */
143 guint32 class_nested = mono_metadata_decode_row_col (&enclosing->image->tables [MONO_TABLE_NESTEDCLASS], i - 1, MONO_NESTED_CLASS_NESTED);
144 guint32 string_offset = mono_metadata_decode_row_col (&enclosing->image->tables [MONO_TABLE_TYPEDEF], class_nested - 1, MONO_TYPEDEF_NAME);
151 }
152 }
153 g_warning ("TypeRef ResolutionScope not yet handled (%d) for %s.%s in image %s", idx, nspace, name, image->name);
155 }
158 }
161 mono_loader_set_error_bad_image (g_strdup_printf ("Image %s with invalid assemblyref token %08x.", image->name, idx));
163 }
169 /* If the assembly did not load, register this as a type load exception */
171 MonoAssemblyName aname;
180 }
183 }
188 {
192 }
194 /* Copy everything mono_metadata_free_array free. */
195 MonoArrayType *
197 {
210 }
212 }
214 /* Copy everything mono_metadata_free_method_signature free. */
215 MonoMethodSignature*
217 {
227 }
229 static void
231 {
241 }
245 {
248 }
250 static void
252 MonoTypeNameFormat format)
253 {
259 MonoTypeNameFormat nested_format;
278 }
280 MonoTypeNameFormat nested_format;
294 }
296 MonoTypeNameFormat nested_format;
310 }
314 g_string_append_printf (str, "%s%d", type->type == MONO_TYPE_VAR ? "!" : "!!", type->data.generic_param->num);
315 else
328 else
333 }
346 MonoTypeNameFormat nested_format;
354 else
368 }
371 else
380 else
385 g_string_append (str, mono_generic_container_get_param_info (klass->generic_container, i)->name);
386 }
389 else
391 }
399 }
400 }
402 /**
403 * mono_type_get_name_full:
404 * @type: a type
405 * @format: the format for the return string.
406 *
407 *
408 * Returns: the string representation in a number of formats:
409 *
410 * if format is MONO_TYPE_NAME_FORMAT_REFLECTION, the return string is
411 * returned in the formatrequired by System.Reflection, this is the
412 * inverse of mono_reflection_parse_type ().
413 *
414 * if format is MONO_TYPE_NAME_FORMAT_IL, it returns a syntax that can
415 * be used by the IL assembler.
416 *
417 * if format is MONO_TYPE_NAME_FORMAT_FULL_NAME
418 *
419 * if format is MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED
420 */
423 {
431 }
433 /**
434 * mono_type_get_full_name:
435 * @class: a class
436 *
437 * Returns: the string representation for type as required by System.Reflection.
438 * The inverse of mono_reflection_parse_type ().
439 */
442 {
444 }
446 /**
447 * mono_type_get_name:
448 * @type: a type
449 *
450 * Returns: the string representation for type as it would be represented in IL code.
451 */
454 {
456 }
458 /*
459 * mono_type_get_underlying_type:
460 * @type: a type
461 *
462 * Returns: the MonoType for the underlying integer type if @type
463 * is an enum and byref is false, otherwise the type itself.
464 */
465 MonoType*
467 {
470 if (type->type == MONO_TYPE_GENERICINST && type->data.generic_class->container_class->enumtype && !type->byref)
473 }
475 /*
476 * mono_class_is_open_constructed_type:
477 * @type: a type
478 *
479 * Returns TRUE if type represents a generics open constructed type
480 * (not all the type parameters required for the instantiation have
481 * been provided).
482 */
483 gboolean
485 {
500 }
501 }
504 inflate_generic_type (MonoImage *image, MonoType *type, MonoGenericContext *context, MonoError *error)
505 {
517 mono_error_set_bad_image (error, image, "MVAR %d (%s) cannot be expanded in this context with %d instantiations",
520 }
522 /*
523 * Note that the VAR/MVAR cases are different from the rest. The other cases duplicate @type,
524 * while the VAR/MVAR duplicates a type from the context. So, we need to ensure that the
525 * ->byref and ->attrs from @type are propagated to the returned type.
526 */
531 }
540 mono_error_set_bad_image (error, image, "VAR %d (%s) cannot be expanded in this context with %d instantiations",
543 }
548 }
558 }
569 }
581 gclass = mono_metadata_lookup_generic_class (gclass->container_class, inst, gclass->is_dynamic);
589 }
601 /* We can't use context->class_inst directly, since it can have more elements */
614 }
617 }
619 }
621 MonoGenericContext *
623 {
625 }
627 MonoGenericContext *
629 {
631 }
633 /*
634 * mono_class_get_generic_container:
635 *
636 * Return the generic container of KLASS which should be a generic type definition.
637 */
638 MonoGenericContainer*
640 {
644 }
646 /*
647 * mono_class_get_generic_class:
648 *
649 * Return the MonoGenericClass of KLASS, which should be a generic instance.
650 */
651 MonoGenericClass*
653 {
657 }
659 /*
660 * mono_class_inflate_generic_type_with_mempool:
661 * @mempool: a mempool
662 * @type: a type
663 * @context: a generics context
664 * @error: error context
665 *
666 * The same as mono_class_inflate_generic_type, but allocates the MonoType
667 * from mempool if it is non-NULL. If it is NULL, the MonoType is
668 * allocated on the heap and is owned by the caller.
669 * The returned type can potentially be the same as TYPE, so it should not be
670 * modified by the caller, and it should be freed using mono_metadata_free_type ().
671 */
672 MonoType*
673 mono_class_inflate_generic_type_with_mempool (MonoImage *image, MonoType *type, MonoGenericContext *context, MonoError *error)
674 {
690 }
691 }
695 }
697 /*
698 * mono_class_inflate_generic_type:
699 * @type: a type
700 * @context: a generics context
701 *
702 * If @type is a generic type and @context is not NULL, instantiate it using the
703 * generics context @context.
704 *
705 * Returns: the instantiated type or a copy of @type. The returned MonoType is allocated
706 * on the heap and is owned by the caller. Returns NULL on error.
707 *
708 * @deprecated Please use mono_class_inflate_generic_type_checked instead
709 */
710 MonoType*
712 {
713 MonoError error;
720 }
722 }
724 /*
725 * mono_class_inflate_generic_type:
726 * @type: a type
727 * @context: a generics context
728 * @error: error context to use
729 *
730 * If @type is a generic type and @context is not NULL, instantiate it using the
731 * generics context @context.
732 *
733 * Returns: the instantiated type or a copy of @type. The returned MonoType is allocated
734 * on the heap and is owned by the caller.
735 */
736 MonoType*
737 mono_class_inflate_generic_type_checked (MonoType *type, MonoGenericContext *context, MonoError *error)
738 {
740 }
742 /*
743 * mono_class_inflate_generic_type_no_copy:
744 *
745 * Same as inflate_generic_type_with_mempool, but return TYPE if no inflation
746 * was done.
747 */
749 mono_class_inflate_generic_type_no_copy (MonoImage *image, MonoType *type, MonoGenericContext *context)
750 {
751 MonoError error;
757 }
764 }
766 /*
767 * mono_class_inflate_generic_class:
768 *
769 * Inflate the class GKLASS with CONTEXT.
770 */
771 MonoClass*
773 {
774 MonoError error;
785 }
787 static MonoGenericContext
788 inflate_generic_context (MonoGenericContext *context, MonoGenericContext *inflate_with, MonoError *error)
789 {
800 }
806 }
810 fail:
812 }
814 /*
815 * mono_class_inflate_generic_method:
816 * @method: a generic method
817 * @context: a generics context
818 *
819 * Instantiate the generic method @method using the generics context @context.
820 *
821 * Returns: the new instantiated method
822 */
823 MonoMethod *
825 {
827 }
829 /**
830 * mono_class_inflate_generic_method_full:
831 *
832 * Instantiate method @method with the generic context @context.
833 * BEWARE: All non-trivial fields are invalid, including klass, signature, and header.
834 * Use mono_method_signature () and mono_method_get_header () to get the correct values.
835 */
836 MonoMethod*
837 mono_class_inflate_generic_method_full (MonoMethod *method, MonoClass *klass_hint, MonoGenericContext *context)
838 {
839 MonoError error;
840 MonoMethod *res = mono_class_inflate_generic_method_full_checked (method, klass_hint, context, &error);
842 /*FIXME do proper error handling - on this case, kill this function. */
846 }
848 /**
849 * mono_class_inflate_generic_method_full_checked:
850 * Same as mono_class_inflate_generic_method_full but return failure using @error.
851 */
852 MonoMethod*
853 mono_class_inflate_generic_method_full_checked (MonoMethod *method, MonoClass *klass_hint, MonoGenericContext *context, MonoError *error)
854 {
858 MonoGenericContext tmp_context;
863 /* The `method' has already been instantiated before => we need to peel out the instantiation and create a new context */
877 }
882 /*
883 * The reason for this hack is to fix the behavior of inflating generic methods that come from a MethodBuilder.
884 * What happens is that instantiating a generic MethodBuilder with its own arguments should create a diferent object.
885 * This is opposite to the way non-SRE MethodInfos behave.
886 *
887 * This happens, for example, when we want to emit a recursive generic method. Given the following C# code:
888 *
889 * void Example<T> () {
890 * Example<T> ();
891 * }
892 *
893 * In Example, the method token must be encoded as: "void Example<!!0>()"
894 *
895 * The reference to the first generic argument, "!!0", must be explicit otherwise it won't be inflated
896 * properly. To get that we need to inflate the MethodBuilder with its own arguments.
897 *
898 * On the other hand, inflating a non-SRE generic method with its own arguments should
899 * return itself. For example:
900 *
901 * MethodInfo m = ... //m is a generic method definition
902 * MethodInfo res = m.MakeGenericMethod (m.GetGenericArguments ());
903 * res == m
904 *
905 * To allow such scenarios we must allow inflation of MethodBuilder to happen in a diferent way than
906 * what happens with regular methods.
907 *
908 * There is one last touch to this madness, once a TypeBuilder is finished, IOW CreateType() is called,
909 * everything should behave like a regular type or method.
910 *
911 */
913 method->klass->image->dynamic && !method->klass->wastypebuilder && /* that is a MethodBuilder from an unfinished TypeBuilder */
914 context->method_inst == mono_method_get_generic_container (method)->context.method_inst; /* and it's been instantiated with its own arguments. */
930 }
938 }
947 mono_error_set_bad_image (error, method->klass->image, "Could not resolve signature of method %s:%s", name, method->name);
950 }
957 }
966 /* Set the generic_container of the result to the generic_container of method */
972 }
973 }
991 }
997 fail:
1001 }
1003 /**
1004 * mono_get_inflated_method:
1005 *
1006 * Obsolete. We keep it around since it's mentioned in the public API.
1007 */
1008 MonoMethod*
1010 {
1012 }
1014 /*
1015 * mono_method_get_context_general:
1016 * @method: a method
1017 * @uninflated: handle uninflated methods?
1018 *
1019 * Returns the generic context of a method or NULL if it doesn't have
1020 * one. For an inflated method that's the context stored in the
1021 * method. Otherwise it's in the method's generic container or in the
1022 * generic container of the method's class.
1023 */
1024 MonoGenericContext*
1026 {
1030 }
1038 }
1040 /*
1041 * mono_method_get_context:
1042 * @method: a method
1043 *
1044 * Returns the generic context for method if it's inflated, otherwise
1045 * NULL.
1046 */
1047 MonoGenericContext*
1049 {
1051 }
1053 /*
1054 * mono_method_get_generic_container:
1055 *
1056 * Returns the generic container of METHOD, which should be a generic method definition.
1057 * Returns NULL if METHOD is not a generic method definition.
1058 * LOCKING: Acquires the loader lock.
1059 */
1060 MonoGenericContainer*
1062 {
1068 container = mono_image_property_lookup (method->klass->image, method, MONO_METHOD_PROP_GENERIC_CONTAINER);
1072 }
1074 /*
1075 * mono_method_set_generic_container:
1076 *
1077 * Sets the generic container of METHOD to CONTAINER.
1078 * LOCKING: Acquires the loader lock.
1079 */
1080 void
1082 {
1085 mono_image_property_insert (method->klass->image, method, MONO_METHOD_PROP_GENERIC_CONTAINER, container);
1086 }
1088 /**
1089 * mono_class_find_enum_basetype:
1090 * @class: The enum class
1091 *
1092 * Determine the basetype of an enum by iterating through its fields. We do this
1093 * in a separate function since it is cheaper than calling mono_class_setup_fields.
1094 */
1097 {
1112 }
1114 /*
1115 * Fetch all the field information.
1116 */
1123 /* class->field.first and idx points into the fieldptr table */
1134 /* FIELD signature == 0x06 */
1138 ftype = mono_metadata_parse_type_full (m, container, MONO_PARSE_FIELD, cols [MONO_FIELD_FLAGS], sig + 1, &sig);
1142 //FIXME do we leak here?
1145 }
1148 }
1151 }
1153 /*
1154 * Checks for MonoClass::exception_type without resolving all MonoType's into MonoClass'es
1155 * It doesn't resolve generic instances, only check the GTD.
1156 */
1157 static gboolean
1159 {
1169 }
1171 }
1173 /**
1174 * mono_class_setup_fields:
1175 * @class: The class to initialize
1176 *
1177 * Initializes the class->fields.
1178 * LOCKING: Assumes the loader lock is held.
1179 */
1180 static void
1182 {
1189 gboolean explicit_size;
1197 if (class->generic_class && class->generic_class->container_class->image->dynamic && !class->generic_class->container_class->wastypebuilder) {
1198 /*
1199 * This happens when a generic instance of an unfinished generic typebuilder
1200 * is used as an element type for creating an array type. We can't initialize
1201 * the fields of this class using the fields of gklass, since gklass is not
1202 * finished yet, fields could be added to it later.
1203 */
1205 }
1212 }
1217 }
1224 /* For generic instances, class->parent might not have been initialized */
1231 }
1232 }
1235 /* we use |= since it may have been set already */
1241 }
1243 /* We can't really enable 16 bytes alignment until the GC supports it.
1244 The whole layout/instance size code must be reviewed because we do alignment calculation in terms of the
1245 boxed instance, which leads to unexplainable holes at the beginning of an object embedding a simd type.
1246 Bug #506144 is an example of this issue.
1248 if (class->simd_type)
1249 class->min_align = 16;
1250 */
1251 /* Get the real size */
1252 explicit_size = mono_metadata_packing_from_typedef (class->image, class->type_token, &packing_size, &real_size);
1258 }
1263 }
1267 }
1272 /* Prevent infinite loops if the class references itself */
1282 }
1284 /*
1285 * Fetch all the field information.
1286 */
1297 /*This memory must come from the image mempool as we don't have a chance to free it.*/
1298 field->type = mono_class_inflate_generic_type_no_copy (class->image, gfield->type, mono_class_get_context (class));
1307 /* class->field.first and idx points into the fieldptr table */
1309 /* The name is needed for fieldrefs */
1314 }
1317 /* FIELD signature == 0x06 */
1319 field->type = mono_metadata_parse_type_full (m, container, MONO_PARSE_FIELD, cols [MONO_FIELD_FLAGS], sig + 1, &sig);
1323 }
1327 guint32 offset;
1333 }
1334 }
1336 /* Only do these checks if we still think this type is blittable */
1347 }
1348 }
1351 }
1352 }
1357 }
1368 }
1369 /* The def_value of fields is compute lazily during vtable creation */
1370 }
1380 }
1383 }
1389 /*valuetypes can't be bigger than 1Mb.*/
1392 }
1394 /**
1395 * mono_class_setup_fields_locking:
1396 * @class: The class to initialize
1397 *
1398 * Initializes the class->fields array of fields.
1399 * Aquires the loader lock.
1400 */
1401 static void
1403 {
1407 }
1409 /*
1410 * mono_class_has_references:
1411 *
1412 * Returns whenever @klass->has_references is set, initializing it if needed.
1413 * Aquires the loader lock.
1414 */
1415 static gboolean
1417 {
1419 /* Be conservative */
1425 }
1426 }
1428 /* useful until we keep track of gc-references in corlib etc. */
1429 #ifdef HAVE_SGEN_GC
1430 #define IS_GC_REFERENCE(t) FALSE
1431 #else
1432 #define IS_GC_REFERENCE(t) ((t)->type == MONO_TYPE_U && class->image == mono_defaults.corlib)
1433 #endif
1435 /*
1436 * mono_type_get_basic_type_from_generic:
1437 * @type: a type
1438 *
1439 * Returns a closed type corresponding to the possibly open type
1440 * passed to it.
1441 */
1442 MonoType*
1444 {
1445 /* When we do generic sharing we let type variables stand for reference types. */
1449 }
1451 /*
1452 * mono_class_layout_fields:
1453 * @class: a class
1454 *
1455 * Compute the placement of fields inside an object or struct, according to
1456 * the layout rules and set the following fields in @class:
1457 * - has_references (if the class contains instance references firled or structs that contain references)
1458 * - has_static_refs (same, but for static fields)
1459 * - instance_size (size of the object in memory)
1460 * - class_size (size needed for the static fields)
1461 * - size_inited (flag set when the instance_size is set)
1462 *
1463 * LOCKING: this is supposed to be called with the loader lock held.
1464 */
1465 void
1467 {
1475 /*
1476 * When we do generic sharing we need to have layout
1477 * information for open generic classes (either with a generic
1478 * context containing type variables or with a generic
1479 * container), so we don't return in that case anymore.
1480 */
1482 /*
1483 * Enable GC aware auto layout: in this mode, reference
1484 * fields are grouped together inside objects, increasing collector
1485 * performance.
1486 * Requires that all classes whose layout is known to native code be annotated
1487 * with [StructLayout (LayoutKind.Sequential)]
1488 * Value types have gc_aware_layout disabled by default, as per
1489 * what the default is for other runtimes.
1490 */
1491 /* corlib is missing [StructLayout] directives in many places */
1496 /* from System.dll, used in metadata/process.h */
1499 }
1501 /* Compute klass->has_references */
1502 /*
1503 * Process non-static fields first, since static fields might recursively
1504 * refer to the class itself.
1505 */
1514 if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype)))))
1516 }
1517 }
1527 if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype)))))
1529 }
1530 }
1539 if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype))))) {
1542 else
1544 }
1545 }
1547 /*
1548 * Compute field layout and total size (not considering static fields)
1549 */
1557 else
1565 else
1570 gint32 align;
1571 guint32 size;
1584 if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype))))) {
1590 }
1591 }
1595 /* This field is a hack inserted by MCS to empty structures */
1597 }
1601 /* FIXME (LAMESPEC): should we also change the min alignment according to pack? */
1603 /* if the field has managed references, we need to force-align it
1604 * see bug #77788
1605 */
1606 if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype)))))
1614 }
1621 }
1622 }
1627 gint32 align;
1628 guint32 size;
1633 /*
1634 * There must be info about all the fields in a type if it
1635 * uses explicit layout.
1636 */
1646 /*
1647 * When we get here, field->offset is already set by the
1648 * loader (for either runtime fields or fields loaded from metadata).
1649 * The offset is from the start of the object: this works for both
1650 * classes and valuetypes.
1651 */
1655 if (MONO_TYPE_IS_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype))))) {
1658 }
1659 }
1661 /*
1662 * Calc max size.
1663 */
1665 }
1668 }
1671 /*
1672 * For small structs, set min_align to at least the struct size to improve
1673 * performance, and since the JIT memset/memcpy code assumes this and generates
1674 * unaligned accesses otherwise. See #78990 for a testcase.
1675 */
1678 }
1682 /*
1683 * Compute static field layout and size
1684 */
1686 gint32 align;
1687 guint32 size;
1691 if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC) || field->type->attrs & FIELD_ATTRIBUTE_LITERAL)
1701 }
1702 }
1706 {
1716 /* .ctor */
1721 }
1723 }
1725 /*
1726 * mono_class_setup_methods:
1727 * @class: a class
1728 *
1729 * Initializes the 'methods' array in the klass.
1730 * Calling this method should be avoided if possible since it allocates a lot
1731 * of long-living MonoMethod structures.
1732 * Methods belonging to an interface are assigned a sequential slot starting
1733 * from 0.
1734 *
1735 * On failure this function sets class->exception_type
1736 */
1737 void
1739 {
1751 }
1754 MonoError error;
1761 /*FIXME make exception_data less opaque so it's possible to dup it here*/
1762 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Generic type definition failed to load"));
1765 }
1767 /* The + 1 makes this always non-NULL to pass the check in mono_class_setup_methods () */
1776 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Could not inflate method %s due to %s", method, mono_error_get_message (&error)));
1782 }
1783 }
1798 }
1821 }
1822 /* element Get (idx11, [idx2, ...]) */
1831 /* element& Address (idx11, [idx2, ...]) */
1840 /* void Set (idx11, [idx2, ...], element) */
1852 setup_generic_array_ifaces (class, class->interfaces [i], methods, first_generic + i * count_generic);
1856 int idx = mono_metadata_translate_token_index (class->image, MONO_TABLE_METHOD, class->method.first + i + 1);
1858 }
1859 }
1863 /*Only assign slots to virtual methods as interfaces are allowed to have static methods.*/
1867 }
1868 }
1870 /* Needed because of the double-checking locking pattern */
1879 }
1881 /*
1882 * mono_class_get_method_by_index:
1883 *
1884 * Returns class->methods [index], initializing class->methods if neccesary.
1885 *
1886 * LOCKING: Acquires the loader lock.
1887 */
1888 MonoMethod*
1890 {
1891 /* Avoid calling setup_methods () if possible */
1898 /*
1899 * If setup_methods () is called later for this class, no duplicates are created,
1900 * since inflate_generic_method guarantees that only one instance of a method
1901 * is created for each context.
1902 */
1903 /*
1904 mono_class_setup_methods (class);
1905 g_assert (m == class->methods [index]);
1906 */
1913 }
1914 }
1916 /*
1917 * mono_class_get_inflated_method:
1918 *
1919 * Given an inflated class CLASS and a method METHOD which should be a method of
1920 * CLASS's generic definition, return the inflated method corresponding to METHOD.
1921 */
1922 MonoMethod*
1924 {
1937 else
1938 return mono_class_inflate_generic_method_full (gklass->methods [i], class, mono_class_get_context (class));
1939 }
1940 }
1943 }
1945 /*
1946 * mono_class_get_vtable_entry:
1947 *
1948 * Returns class->vtable [offset], computing it if neccesary.
1949 * LOCKING: Acquires the loader lock.
1950 */
1951 MonoMethod*
1953 {
1957 /*
1958 * szarrays do not overwrite any methods of Array, so we can avoid
1959 * initializing their vtables in some cases.
1960 */
1964 }
1975 }
1978 }
1980 /*
1981 * mono_class_get_vtable_size:
1982 *
1983 * Return the vtable size for KLASS.
1984 */
1985 int
1987 {
1991 }
1993 /*This method can fail the class.*/
1994 static void
1996 {
2001 guint32 last;
2011 }
2021 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Generic type definition failed to load"));
2024 }
2043 }
2045 int first = mono_metadata_properties_from_typedef (class->image, mono_metadata_token_index (class->type_token) - 1, &last);
2053 }
2054 }
2060 mono_metadata_decode_table_row (class->image, MONO_TABLE_PROPERTY, i, cols, MONO_PROPERTY_SIZE);
2063 properties [i - first].name = mono_metadata_string_heap (class->image, cols [MONO_PROPERTY_NAME]);
2072 /* It seems like the MONO_METHOD_SEMA_METHOD column needs no remapping */
2073 method = mono_get_method (class->image, MONO_TOKEN_METHOD_DEF | cols [MONO_METHOD_SEMA_METHOD], class);
2074 else
2086 }
2087 }
2088 }
2089 }
2090 /*Flush any pending writes as we do double checked locking on class->properties */
2093 /* Leave this assignment as the last op in the function */
2097 }
2101 {
2106 ;
2114 }
2116 /*This method can fail the class.*/
2117 static void
2119 {
2124 guint32 last;
2135 }
2145 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Generic type definition failed to load"));
2148 }
2162 event->add = gevent->add ? mono_class_inflate_generic_method_full (gevent->add, class, context) : NULL;
2163 event->remove = gevent->remove ? mono_class_inflate_generic_method_full (gevent->remove, class, context) : NULL;
2164 event->raise = gevent->raise ? mono_class_inflate_generic_method_full (gevent->raise, class, context) : NULL;
2167 }
2171 }
2173 first = mono_metadata_events_from_typedef (class->image, mono_metadata_token_index (class->type_token) - 1, &last);
2179 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Generic type definition failed to load"));
2182 }
2183 }
2202 /* It seems like the MONO_METHOD_SEMA_METHOD column needs no remapping */
2203 method = mono_get_method (class->image, MONO_TOKEN_METHOD_DEF | cols [MONO_METHOD_SEMA_METHOD], class);
2204 else
2224 n++;
2226 }
2228 /* NULL terminated */
2231 }
2234 }
2235 }
2236 }
2237 /*Flush any pending writes as we do double checked locking on class->properties */
2240 /* Leave this assignment as the last op in the function */
2244 }
2246 /*
2247 * Global pool of interface IDs, represented as a bitset.
2248 * LOCKING: this is supposed to be accessed with the loader lock held.
2249 */
2252 /*
2253 * mono_unload_interface_ids:
2254 * @bitset: bit set of interface IDs
2255 *
2256 * When an image is unloaded, the interface IDs associated with
2257 * the image are put back in the global pool of IDs so the numbers
2258 * can be reused.
2259 */
2260 void
2262 {
2266 }
2268 /*
2269 * mono_get_unique_iid:
2270 * @class: interface
2271 *
2272 * Assign a unique integer ID to the interface represented by @class.
2273 * The ID will positive and as small as possible.
2274 * LOCKING: this is supposed to be called with the loader lock held.
2275 * Returns: the new ID.
2276 */
2277 static guint
2279 {
2286 }
2295 }
2297 /* set the bit also in the per-image set */
2303 }
2306 }
2317 }
2318 printf ("Interface: assigned id %d to %s|%s|%d\n", iid, class->image->name, type_name, generic_id);
2320 }
2324 }
2326 static void
2328 {
2343 }
2344 }
2346 GPtrArray*
2348 {
2353 }
2355 static int
2361 }
2363 /*FIXME verify all callers if they should switch to mono_class_interface_offset_with_variance*/
2364 int
2367 itf,
2371 compare_interface_ids);
2376 }
2377 }
2379 /*
2380 * mono_class_interface_offset_with_variance:
2381 *
2382 * Return the interface offset of @itf in @klass. Sets @non_exact_match to TRUE if the match required variance check
2383 * If @itf is an interface with generic variant arguments, try to find the compatible one.
2384 *
2385 * Note that this function is responsible for resolving ambiguities. Right now we use whatever ordering interfaces_packed gives us.
2386 *
2387 * FIXME figure out MS disambiguation rules and fix this function.
2388 */
2389 int
2390 mono_class_interface_offset_with_variance (MonoClass *klass, MonoClass *itf, gboolean *non_exact_match) {
2403 }
2404 }
2407 }
2409 static void
2415 printf ("Packed interface table for class %s has size %d\n", klass->name, klass->interface_offsets_count);
2427 else
2431 for (i = 0; i < ((((klass->max_interface_id + 1) >> 3)) + (((klass->max_interface_id + 1) & 7)? 1 :0)); i++)
2447 }
2449 }
2450 ancestor_level ++;
2452 }
2453 }
2457 {
2462 }
2466 {
2468 }
2470 static void
2472 {
2492 }
2494 /* this won't be needed once bug #325495 is completely fixed
2495 * though we'll need something similar to know which interfaces to allow
2496 * in arrays when they'll be lazyly created
2497 *
2498 * FIXME: System.Array/InternalEnumerator don't need all this interface fabrication machinery.
2499 * MS returns diferrent types based on which instance is called. For example:
2500 * object obj = new byte[10][];
2501 * Type a = ((IEnumerable<byte[]>)obj).GetEnumerator ().GetType ();
2502 * Type b = ((IEnumerable<IList<byte>>)obj).GetEnumerator ().GetType ();
2503 * a != b ==> true
2504 *
2505 * Fixing this should kill quite some code, save some bits and improve compatibility.
2506 */
2509 {
2518 gboolean internal_enumerator;
2519 gboolean eclass_is_valuetype;
2524 }
2529 if (class->generic_class && class->nested_in == mono_defaults.array_class && strcmp (class->name, "InternalEnumerator`1") == 0) {
2530 /*
2531 * For a Enumerator<T[]> we need to get the list of interfaces for T.
2532 */
2541 }
2542 }
2544 /*
2545 * with this non-lazy impl we can't implement all the interfaces so we do just the minimal stuff
2546 * for deep levels of arrays of arrays (string[][] has all the interfaces, string[][][] doesn't)
2547 */
2557 }
2561 /*
2562 * Arrays in 2.0 need to implement a number of generic interfaces
2563 * (IList`1, ICollection`1, IEnumerable`1 for a number of types depending
2564 * on the element class). We collect the types needed to build the
2565 * instantiations in interfaces at intervals of 3, because 3 are
2566 * the generic interfaces needed to implement.
2567 */
2571 /* IList, ICollection, IEnumerable */
2577 }
2589 idepth--;
2591 /* we add object for interfaces and the supertypes for the other
2592 * types. The last of the supertypes is the element class itself which we
2593 * already created the explicit interfaces for (so we include it for IEnumerator
2594 * and exclude it for arrays).
2595 */
2597 interface_count++;
2598 else
2604 }
2605 /* IList, ICollection, IEnumerable */
2609 real_count += (MONO_CLASS_IS_INTERFACE (eclass) ? 1 : idepth) + eclass->interface_offsets_count;
2612 }
2623 }
2624 }
2629 }
2634 }
2635 }
2639 }
2640 }
2642 /* instantiate the generic interfaces */
2649 }
2652 /* instantiate IEnumerator<iface> */
2655 }
2659 interfaces [j] = inflate_class_one_arg (generic_ienumerator_class, mono_defaults.object_class);
2660 j ++;
2664 j ++;
2665 }
2666 }
2668 interfaces [j] = inflate_class_one_arg (generic_ienumerator_class, eclass->interfaces_packed [i]);
2669 j ++;
2670 }
2672 interfaces [j++] = inflate_class_one_arg (generic_ienumerator_class, array_class_get_if_rank (valuetype_types [0], original_rank));
2673 }
2675 interfaces [j] = inflate_class_one_arg (generic_ienumerator_class, array_class_get_if_rank (valuetype_types [1], original_rank));
2676 }
2677 #if 0
2678 {
2684 }
2686 }
2687 #endif
2690 }
2692 static int
2694 {
2699 }
2701 }
2703 /*
2704 * Return the number of virtual methods.
2705 * Even for interfaces we can't simply return the number of methods as all CLR types are allowed to have static methods.
2706 * Return -1 on failure.
2707 * FIXME It would be nice if this information could be cached somewhere.
2708 */
2709 static int
2711 {
2713 guint32 flags;
2714 class = mono_class_get_generic_type_definition (class); /*We can find this information by looking at the GTD*/
2725 }
2728 flags = mono_metadata_decode_table_row_col (class->image, MONO_TABLE_METHOD, class->method.first + i, MONO_METHOD_FLAGS);
2732 }
2733 }
2735 }
2737 /*
2738 * LOCKING: this is supposed to be called with the loader lock held.
2739 * Return -1 on failure and set exception_type
2740 */
2741 static int
2743 {
2754 /*
2755 * get the implicit generic interfaces for either the arrays or for System.Array/InternalEnumerator<T>
2756 * implicit interfaces have the property that they are assigned the same slot in the
2757 * vtables for compatible interfaces
2758 */
2759 array_interfaces = get_implicit_generic_array_interfaces (class, &num_array_interfaces, &is_enumerator);
2761 /* compute maximum number of slots and maximum interface id */
2772 }
2779 }
2781 }
2782 }
2788 }
2793 }
2795 /* compute vtable offset for interfaces */
2802 }
2811 /*Force the sharing of interface offsets between parent and subtypes.*/
2816 }
2818 }
2819 }
2834 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Error calculating interface offset of %s", name));
2837 }
2839 }
2841 }
2846 }
2852 ienumerator_offset = interface_offsets_full [class->interfaces [ienumerator_idx]->interface_id];
2858 else
2860 /*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);*/
2861 }
2865 int icollection_iface_idx = find_array_interface (class->interfaces [ilist_iface_idx], "ICollection`1");
2866 int ienumerable_iface_idx = find_array_interface (class->interfaces [ilist_iface_idx], "IEnumerable`1");
2868 icollection_offset = interface_offsets_full [class->interfaces [ilist_iface_idx]->interfaces [icollection_iface_idx]->interface_id];
2869 ienumerable_offset = interface_offsets_full [class->interfaces [ilist_iface_idx]->interfaces [ienumerable_iface_idx]->interface_id];
2880 else
2882 /*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);*/
2883 }
2884 }
2885 }
2889 interface_offsets_count ++;
2890 }
2891 }
2893 /*
2894 * We might get called twice: once from mono_class_init () then once from
2895 * mono_class_setup_vtable ().
2896 */
2901 class->interfaces_packed = mono_image_alloc (class->image, sizeof (MonoClass*) * interface_offsets_count);
2902 class->interface_offsets_packed = mono_image_alloc (class->image, sizeof (guint16) * interface_offsets_count);
2903 class->interface_bitmap = mono_image_alloc0 (class->image, (sizeof (guint8) * ((max_iid + 1) >> 3)) + (((max_iid + 1) & 7)? 1 :0));
2909 /*if (num_array_interfaces)
2910 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]);*/
2911 interface_offsets_count ++;
2912 }
2913 }
2914 }
2920 //printf ("JUST DONE: ");
2921 //print_implemented_interfaces (class);
2924 fail:
2929 }
2931 /*
2932 * Setup interface offsets for interfaces.
2933 * Initializes:
2934 * - class->max_interface_id
2935 * - class->interface_offsets_count
2936 * - class->interfaces_packed
2937 * - class->interface_offsets_packed
2938 * - class->interface_bitmap
2939 *
2940 * This function can fail @class.
2941 */
2942 void
2944 {
2950 }
2952 /*
2953 * mono_class_setup_vtable:
2954 *
2955 * Creates the generic vtable of CLASS.
2956 * Initializes the following fields in MonoClass:
2957 * - vtable
2958 * - vtable_size
2959 * Plus all the fields initialized by setup_interface_offsets ().
2960 * If there is an error during vtable construction, class->exception_type is set.
2961 *
2962 * LOCKING: Acquires the loader lock.
2963 */
2964 void
2966 {
2969 guint32 type_token;
2978 /* The debugger currently depends on this */
2982 /* This sets method->slot for all methods if this is an interface */
2985 }
2995 }
3005 }
3021 }
3022 }
3026 }
3029 }
3031 /* The following call fails if there are missing methods in the type */
3033 }
3043 }
3045 #define DEBUG_INTERFACE_VTABLE_CODE 0
3046 #define TRACE_INTERFACE_VTABLE_CODE 0
3047 #define VERIFY_INTERFACE_VTABLE_CODE 0
3048 #define VTABLE_SELECTOR (1)
3050 #if (TRACE_INTERFACE_VTABLE_CODE|DEBUG_INTERFACE_VTABLE_CODE)
3051 #define DEBUG_INTERFACE_VTABLE(stmt) do {\
3052 if (!(VTABLE_SELECTOR)) break; \
3053 stmt;\
3054 } while (0)
3055 #else
3056 #define DEBUG_INTERFACE_VTABLE(stmt)
3057 #endif
3059 #if TRACE_INTERFACE_VTABLE_CODE
3060 #define TRACE_INTERFACE_VTABLE(stmt) do {\
3061 if (!(VTABLE_SELECTOR)) break; \
3062 stmt;\
3063 } while (0)
3064 #else
3065 #define TRACE_INTERFACE_VTABLE(stmt)
3066 #endif
3068 #if VERIFY_INTERFACE_VTABLE_CODE
3069 #define VERIFY_INTERFACE_VTABLE(stmt) do {\
3070 if (!(VTABLE_SELECTOR)) break; \
3071 stmt;\
3072 } while (0)
3073 #else
3074 #define VERIFY_INTERFACE_VTABLE(stmt)
3075 #endif
3078 #if (TRACE_INTERFACE_VTABLE_CODE|DEBUG_INTERFACE_VTABLE_CODE)
3081 {
3091 }
3097 }
3101 }
3102 static void
3110 }
3112 #endif
3113 static gboolean
3114 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) {
3120 }
3126 }
3130 }
3133 }
3134 }
3138 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Could not resolve the signature of a virtual method"));
3140 }
3147 }
3149 /* CAS - SecurityAction.InheritanceDemand on interface */
3152 }
3167 }
3171 }
3172 if (! mono_metadata_signature_equal (mono_method_signature (cm), mono_method_signature (im))) {
3177 }
3181 }
3185 }
3186 if ((ic_name == NULL) || ((strcmp (ic_name, "IEnumerable`1") != 0) && (strcmp (ic_name, "ICollection`1") != 0) && (strcmp (ic_name, "IList`1") != 0))) {
3189 }
3195 }
3200 }
3201 subname ++;
3205 }
3210 }
3211 subname ++;
3215 }
3218 /* CAS - SecurityAction.InheritanceDemand on interface */
3221 }
3228 }
3229 }
3231 #if (TRACE_INTERFACE_VTABLE_CODE|DEBUG_INTERFACE_VTABLE_CODE)
3232 static void
3240 mono_class_get_namespace (method_class), mono_class_get_name (method_class), mono_method_get_name (method),
3241 mono_class_get_namespace (override_class), mono_class_get_name (override_class), mono_method_get_name (override));
3242 }
3243 static void
3251 }
3252 }
3253 static void
3254 print_vtable_full (MonoClass *class, MonoMethod** vtable, int size, int first_non_interface_slot, const char *message, gboolean print_interfaces) {
3264 }
3270 }
3278 }
3279 }
3282 }
3283 #endif
3285 #if VERIFY_INTERFACE_VTABLE_CODE
3286 static int
3288 {
3293 }
3295 }
3297 static void
3299 {
3323 printf ("\tInvalid method %s at index %d with vtable of length %d\n", full_name, slot, class->vtable_size);
3325 }
3328 char *other_name = class->vtable [slot] ? mono_method_full_name (class->vtable [slot], TRUE) : g_strdup ("[null value]");
3331 }
3334 }
3336 }
3337 #endif
3339 static void
3340 print_unimplemented_interface_method_info (MonoClass *class, MonoClass *ic, MonoMethod *im, int im_slot, MonoMethod **overrides, int onum) {
3348 }
3361 }
3368 }
3369 }
3371 static gboolean
3373 {
3380 if (mono_class_get_generic_type_definition (body->klass) != mono_class_get_generic_type_definition (class)) {
3381 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Method belongs to a different class than the declared one"));
3383 }
3387 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Method must not be static to override a base type"));
3388 else
3389 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Method must be virtual to override a base type"));
3391 }
3395 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Cannot override a static method in a base type"));
3396 else
3397 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Cannot override a non virtual method in a base type"));
3399 }
3402 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Method overrides a class or interface that extended or implemented by this type"));
3404 }
3405 }
3407 }
3408 /*
3409 * LOCKING: this is supposed to be called with the loader lock held.
3410 */
3411 void
3413 {
3421 gpointer class_iter;
3422 #if (DEBUG_INTERFACE_VTABLE_CODE|TRACE_INTERFACE_VTABLE_CODE)
3424 #endif
3439 }
3442 }
3450 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Parent %s failed to load", name));
3453 }
3457 }
3464 /* printf ("METAINIT %s.%s\n", class->name_space, class->name); */
3473 /* Optimized version for generic instances */
3482 }
3488 tmp [i] = mono_class_inflate_generic_method_full (gklass->vtable [i], class, mono_class_get_context (class));
3490 }
3494 /* Have to set method->slot for abstract virtual methods */
3499 }
3502 }
3510 // Also inherit parent interface vtables, just as a starting point.
3511 // This is needed otherwise bug-77127.exe fails when the property methods
3512 // have different names in the iterface and the class, because for child
3513 // classes the ".override" information is not used anymore.
3517 /*FIXME this is now dead code as this condition will never hold true.
3518 Since interface offsets are inherited then the offset of an interface implemented
3519 by a parent will never be the out of it's vtable boundary.
3520 */
3526 TRACE_INTERFACE_VTABLE (printf (" +++ Inheriting interface %s.%s\n", parent_interface->name_space, parent_interface->name));
3529 TRACE_INTERFACE_VTABLE (printf (" --- Inheriting: [%03d][(%03d)+(%03d)] => [%03d][(%03d)+(%03d)]\n",
3532 }
3533 }
3535 }
3536 }
3538 TRACE_INTERFACE_VTABLE (print_vtable_full (class, vtable, cur_slot, first_non_interface_slot, "AFTER INHERITING PARENT VTABLE", TRUE));
3539 /* override interface methods */
3548 }
3560 }
3561 }
3563 TRACE_INTERFACE_VTABLE (print_vtable_full (class, vtable, cur_slot, first_non_interface_slot, "AFTER OVERRIDING INTERFACE METHODS", FALSE));
3565 /*
3566 * Create a list of virtual methods to avoid calling
3567 * mono_class_get_virtual_methods () which is slow because of the metadata
3568 * optimization.
3569 */
3570 {
3577 }
3580 }
3582 // Loop on all implemented interfaces...
3586 gboolean interface_is_explicitly_implemented_by_class;
3596 // Check if this interface is explicitly implemented (instead of just inherited)
3600 for (implemented_interfaces_index = 0; implemented_interfaces_index < class->interface_count; implemented_interfaces_index++) {
3604 }
3605 }
3608 }
3610 // Loop on all interface methods...
3614 MonoMethod *override_im = (override_map != NULL) ? g_hash_table_lookup (override_map, im) : NULL;
3619 // If there is an explicit implementation, just use it right away,
3620 // otherwise look for a matching method
3623 gpointer iter;
3626 // First look for a suitable method among the class methods
3630 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)));
3631 if (check_interface_method_override (class, im, cm, TRUE, interface_is_explicitly_implemented_by_class, (vtable [im_slot] == NULL), security_enabled)) {
3634 /* Why do we need this? */
3637 }
3638 }
3642 }
3644 // If the slot is still empty, look in all the inherited virtual methods...
3647 // Reverse order, so that last added methods are preferred
3651 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));
3652 if ((cm != NULL) && check_interface_method_override (class, im, cm, FALSE, FALSE, TRUE, security_enabled)) {
3655 /* Why do we need this? */
3658 }
3660 }
3664 }
3665 }
3668 }
3669 }
3670 }
3672 // If the class is not abstract, check that all its interface slots are full.
3673 // The check is done here and not directly at the end of the loop above because
3674 // it can happen (for injected generic array interfaces) that the same slot is
3675 // processed multiple times (those interfaces have overlapping slots), and it
3676 // will not always be the first pass the one that fills the slot.
3692 TRACE_INTERFACE_VTABLE (printf (" [class is not abstract, checking slot %d for interface '%s'.'%s', method %s, slot check is %d]\n",
3697 }
3698 }
3699 }
3700 }
3702 TRACE_INTERFACE_VTABLE (print_vtable_full (class, vtable, cur_slot, first_non_interface_slot, "AFTER SETTING UP INTERFACE METHODS", FALSE));
3706 /*
3707 * If the method is REUSE_SLOT, we must check in the
3708 * base class for a method to override.
3709 */
3713 gpointer k_iter;
3726 }
3731 /* CAS - SecurityAction.InheritanceDemand */
3734 }
3748 }
3749 }
3755 }
3758 }
3760 /*Non final newslot methods must be given a non-interface vtable slot*/
3761 if ((cm->flags & METHOD_ATTRIBUTE_NEW_SLOT) && !(cm->flags & METHOD_ATTRIBUTE_FINAL) && cm->slot >= 0)
3769 }
3771 /* override non interface methods */
3784 }
3785 }
3787 /*
3788 * If a method occupies more than one place in the vtable, and it is
3789 * overriden, then change the other occurances too.
3790 */
3797 }
3801 }
3806 /* Ensure that all vtable slots are filled with concrete instance methods */
3809 if (vtable [i] == NULL || (vtable [i]->flags & (METHOD_ATTRIBUTE_ABSTRACT | METHOD_ATTRIBUTE_STATIC))) {
3812 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Type %s has invalid vtable method slot %d with method %s", type_name, i, method_name));
3816 }
3817 }
3818 }
3827 /* Check that the vtable_size value computed in mono_class_init () is correct */
3831 }
3833 /* Try to share the vtable with our parent. */
3834 if (class->parent && (class->parent->vtable_size == class->vtable_size) && (memcmp (class->parent->vtable, vtable, sizeof (gpointer) * class->vtable_size) == 0)) {
3842 }
3844 DEBUG_INTERFACE_VTABLE (print_vtable_full (class, class->vtable, class->vtable_size, first_non_interface_slot, "FINALLY", FALSE));
3852 icount++;
3854 printf ("VTable %s (vtable entries = %d, interfaces = %d)\n", mono_type_full_name (&class->byval_arg),
3864 }
3865 }
3877 }
3885 }
3886 }
3887 }
3888 }
3893 fail:
3894 {
3896 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("VTable setup of type %s failed", name));
3902 }
3903 }
3905 /*
3906 * mono_method_get_vtable_slot:
3907 *
3908 * Returns method->slot, computing it if neccesary. Return -1 on failure.
3909 * LOCKING: Acquires the loader lock.
3910 *
3911 * FIXME Use proper MonoError machinery here.
3912 */
3913 int
3915 {
3921 }
3923 }
3925 /**
3926 * mono_method_get_vtable_index:
3927 * @method: a method
3928 *
3929 * Returns the index into the runtime vtable to access the method or,
3930 * in the case of a virtual generic method, the virtual generic method
3931 * thunk. Returns -1 on failure.
3932 *
3933 * FIXME Use proper MonoError machinery here.
3934 */
3935 int
3937 {
3942 }
3944 }
3951 static void
3953 {
3966 }
3973 }
3974 }
3984 static int
3986 {
3996 count_generic++;
3998 }
3999 }
4019 }
4025 i++;
4026 }
4027 /*g_print ("array generic methods: %d\n", count_generic);*/
4032 }
4034 static void
4036 {
4037 MonoGenericContext tmp_context;
4042 //g_print ("setting up array interface: %s\n", mono_type_get_name_full (&iface->byval_arg, 0));
4049 methods [pos++] = mono_marshal_get_generic_array_helper (class, iface, generic_array_method_info [i].name, inflated);
4050 }
4051 }
4055 {
4064 }
4066 static void
4068 {
4073 exception_data = concat_two_strings_with_zero (class->image, error->class_name, error->assembly_name);
4077 exception_data = concat_two_strings_with_zero (class->image, error->class_name, error->member_name);
4086 else
4094 }
4100 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.";
4101 else
4106 }
4114 }
4117 }
4119 /**
4120 * mono_class_init:
4121 * @class: the class to initialize
4122 *
4123 * Compute the instance_size, class_size and other infos that cannot be
4124 * computed at mono_class_get() time. Also compute vtable_size if possible.
4125 * Returns TRUE on success or FALSE if there was a problem in loading
4126 * the type (incorrect assemblies, missing assemblies, methods, etc).
4127 *
4128 * LOCKING: Acquires the loader lock.
4129 */
4130 gboolean
4132 {
4134 MonoCachedClassInfo cached_info;
4135 gboolean has_cached_info;
4139 /* Double-checking locking pattern */
4143 /*g_print ("Init class %s\n", class->name);*/
4145 /* We do everything inside the lock to prevent races */
4150 /* Somebody might have gotten in before us */
4152 }
4156 /* this indicates a cyclic dependency */
4158 }
4163 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, concat_two_strings_with_zero (class->image, class->name, class->image->assembly_name));
4165 }
4175 }
4176 }
4178 /* CAS - SecurityAction.InheritanceDemand */
4179 if (mono_is_security_manager_active () && class->parent && (class->parent->flags & TYPE_ATTRIBUTE_HAS_SECURITY)) {
4181 }
4197 // FIXME: Why is this needed ?
4201 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Generic Type Defintion failed to init"));
4203 }
4207 }
4214 if (class->generic_class || class->image->dynamic || !class->type_token || (has_cached_info && !cached_info.has_nested_classes))
4217 /*
4218 * Computes the size used by the fields, and their locations
4219 */
4229 }
4230 else
4235 }
4237 /* Initialize arrays */
4244 }
4245 }
4252 /*
4253 * Initialize the rest of the data without creating a generic vtable if possible.
4254 * If possible, also compute vtable_size, so mono_class_create_runtime_vtable () can
4255 * also avoid computing a generic vtable.
4256 */
4258 /* AOT case */
4266 /* SZARRAY case */
4272 }
4276 /* Generic instance case */
4285 }
4289 /* General case */
4291 /* ghcimpl is not currently used
4292 class->ghcimpl = 1;
4293 if (class->parent) {
4294 MonoMethod *cmethod = class->vtable [ghc_slot];
4295 if (cmethod->is_inflated)
4296 cmethod = ((MonoMethodInflated*)cmethod)->declaring;
4297 if (cmethod == default_ghc) {
4298 class->ghcimpl = 0;
4299 }
4300 }
4301 */
4303 /* Interfaces and valuetypes are not supposed to have finalizers */
4313 /* FIXME: Optimize this */
4318 }
4321 /* Check that this is really the finalizer method */
4336 }
4337 }
4338 }
4339 }
4340 }
4342 /* C# doesn't allow interfaces to have cctors */
4348 /* The find_method function ignores the 'flags' argument */
4362 }
4363 }
4364 }
4365 }
4366 }
4369 /*
4370 * This is an embedding API break, since the caller might assume that
4371 * mono_class_init () constructs a generic vtable, so vtable construction errors
4372 * are visible right after the mono_class_init (), and not after
4373 * mono_class_vtable ().
4374 */
4376 /* This will compute class->parent->vtable_size for some classes */
4381 }
4385 /* FIXME: Get rid of this somehow */
4390 }
4393 }
4397 }
4403 }
4407 leave:
4408 /* Because of the double-checking locking pattern */
4416 }
4418 }
4426 }
4428 static gboolean
4430 {
4431 /* FIXME: allow the dynamic case for our compilers and with full trust */
4434 else
4436 }
4438 /*
4439 * LOCKING: this assumes the loader lock is held
4440 */
4441 void
4443 {
4456 /*
4457 * do not set the valuetype bit for System.ValueType.
4458 * class->valuetype = 1;
4459 */
4462 /*
4463 * do not set the valuetype bit for System.Enum.
4464 * class->valuetype = 1;
4465 */
4474 }
4475 }
4488 }
4493 }
4499 }
4514 }
4523 }
4538 }
4544 }
4549 }
4553 }
4554 }
4556 }
4561 }
4563 /*
4564 * COM initialization (using mono_init_com_types) is delayed until needed.
4565 * However when a [ComImport] attribute is present on a type it will trigger
4566 * the initialization. This is not a problem unless the BCL being executed
4567 * lacks the types that COM depends on (e.g. Variant on Silverlight).
4568 */
4569 static void
4571 {
4572 /* we don't always allow COM initialization under the CoreCLR (e.g. Moonlight does not require it) */
4574 /* but some other CoreCLR user could requires it for their platform (i.e. trusted) code */
4576 /* but it can not be made available for application (i.e. user code) since all COM calls
4577 * are considered native calls. In this case we fail with a TypeLoadException (just like
4578 * Silverlight 2 does */
4581 }
4582 }
4583 /* FIXME : we should add an extra checks to ensure COM can be initialized properly before continuing */
4585 }
4587 /*
4588 * LOCKING: this assumes the loader lock is held
4589 */
4590 void
4592 {
4593 gboolean system_namespace;
4598 /* if root of the hierarchy */
4603 }
4608 }
4611 /* Imported COM Objects always derive from __ComObject. */
4616 }
4618 /* set the parent to something useful and safe, but mark the type as broken */
4621 }
4626 /*
4627 * If the parent is a generic instance, we may get
4628 * called before it is fully initialized, especially
4629 * before it has its name.
4630 */
4632 }
4639 else
4651 }
4653 if (class->parent->enumtype || (is_corlib_image (class->parent->image) && (strcmp (class->parent->name, "ValueType") == 0) &&
4656 if (is_corlib_image (class->parent->image) && ((strcmp (class->parent->name, "Enum") == 0) && (strcmp (class->parent->name_space, "System") == 0))) {
4658 }
4659 /*class->enumtype = class->parent->enumtype; */
4662 /* initialize com types if COM interfaces are present */
4666 }
4668 }
4670 /*
4671 * mono_class_setup_supertypes:
4672 * @class: a class
4673 *
4674 * Build the data structure needed to make fast type checks work.
4675 * This currently sets two fields in @class:
4676 * - idepth: distance between @class and System.Object in the type
4677 * hierarchy + 1
4678 * - supertypes: array of classes: each element has a class in the hierarchy
4679 * starting from @class up to System.Object
4680 *
4681 * LOCKING: this assumes the loader lock is held
4682 */
4683 void
4685 {
4695 else
4703 memcpy (class->supertypes, class->parent->supertypes, class->parent->idepth * sizeof (gpointer));
4706 }
4707 }
4709 /**
4710 * mono_class_create_from_typedef:
4711 * @image: image where the token is valid
4712 * @type_token: typedef token
4713 *
4714 * Create the MonoClass* representing the specified type token.
4715 * @type_token must be a TypeDef token.
4716 */
4719 {
4730 guint32 nesting_tokeen;
4737 if ((class = mono_internal_hash_table_lookup (&image->class_cache, GUINT_TO_POINTER (type_token)))) {
4740 }
4762 /*
4763 * Check whether we're a generic type definition.
4764 */
4770 }
4776 /*WARNING: this must satisfy mono_metadata_type_hash*/
4782 }
4790 }
4791 }
4793 /* do this early so it's available for interfaces in setup_mono_type () */
4801 }
4802 }
4806 /* uses ->valuetype, which is initialized by mono_class_setup_parent above */
4812 #ifdef HOST_WIN32
4815 #endif
4825 }
4830 }
4832 /*g_print ("Load class %s\n", name);*/
4834 /*
4835 * Compute the field and method lists
4836 */
4847 }
4852 else
4857 else
4860 /* reserve space to store vector pointer in arrays */
4864 }
4873 }
4875 }
4877 /*
4878 * If we're a generic type definition, load the constraints.
4879 * We must do this after the class has been constructed to make certain recursive scenarios
4880 * work.
4881 */
4882 if (class->generic_container && !mono_metadata_load_generic_param_constraints_full (image, type_token, class->generic_container)){
4884 char *error = concat_two_strings_with_zero (class->image, class_name, class->image->assembly_name);
4890 }
4892 if (class->image->assembly_name && !strcmp (class->image->assembly_name, "Mono.Simd") && !strcmp (nspace, "Mono.Simd")) {
4894 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");
4895 }
4902 }
4904 /** is klass Nullable<T>? */
4905 gboolean
4907 {
4910 }
4913 /** if klass is T? return T */
4914 MonoClass*
4916 {
4919 }
4921 /*
4922 * Create the `MonoClass' for an instantiation of a generic type.
4923 * We only do this if we actually need it.
4924 */
4925 MonoClass*
4927 {
4934 }
4942 /*
4943 * FIXME: the nested type context should include everything the
4944 * nesting context should have, but it may also have additional
4945 * generic parameters...
4946 */
4949 }
4975 /*
4976 * We're not interested in the nested classes of a generic instance.
4977 * We use the generic type definition to look for nested classes.
4978 */
4981 klass->parent = mono_class_inflate_generic_class (gklass->parent, mono_generic_class_get_context (gclass));
4982 }
4990 }
4998 /*
4999 * For enums, gklass->fields might not been set, but instance_size etc. is
5000 * already set in mono_reflection_create_internal_class (). For non-enums,
5001 * these will be computed normally in mono_class_layout_fields ().
5002 */
5006 }
5007 }
5011 inflated_classes ++;
5017 }
5020 make_generic_param_class (MonoGenericParam *param, MonoImage *image, gboolean is_mvar, MonoGenericParamInfo *pinfo)
5021 {
5027 /* FIXME: */
5039 }
5048 }
5051 }
5058 ;
5063 pos++;
5066 else
5075 }
5087 /* FIXME: shouldn't this be ->type_token? */
5093 }
5095 #define FAST_CACHE_SIZE 1024
5103 {
5111 }
5113 static void
5115 {
5122 }
5128 else
5130 }
5133 }
5135 /*
5136 * LOCKING: Acquires the loader lock.
5137 */
5138 MonoClass *
5139 mono_class_from_generic_parameter (MonoGenericParam *param, MonoImage *image, gboolean is_mvar)
5140 {
5152 }
5161 }
5162 }
5170 // FIXME: 'klass' should not be null
5171 // But, monodis creates GenericContainers without associating a owner to it
5173 }
5174 }
5182 else
5187 /* FIXME: Should this go inside 'make_generic_param_klass'? */
5191 }
5193 MonoClass *
5195 {
5212 }
5228 /* Can pointers get boxed? */
5246 }
5250 {
5254 /* FIXME: These should be allocate from a mempool as well, but which one ? */
5264 }
5275 result->flags = TYPE_ATTRIBUTE_CLASS; /* | (el_class->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK); */
5276 /* Can pointers get boxed? */
5295 }
5297 MonoClass *
5299 {
5357 }
5360 }
5362 /**
5363 * mono_type_retrieve_from_typespec
5364 * @image: context where the image is created
5365 * @type_spec: typespec token
5366 * @context: the generic context used to evaluate generic instantiations in
5367 */
5369 mono_type_retrieve_from_typespec (MonoImage *image, guint32 type_spec, MonoGenericContext *context, gboolean *did_inflate, MonoError *error)
5370 {
5379 mono_error_set_type_load_name (error, name, assembly, "Could not resolve typespec token %08x", type_spec);
5381 }
5392 }
5393 }
5395 }
5397 /**
5398 * mono_class_create_from_typespec
5399 * @image: context where the image is created
5400 * @type_spec: typespec token
5401 * @context: the generic context used to evaluate generic instantiations in
5402 */
5404 mono_class_create_from_typespec (MonoImage *image, guint32 type_spec, MonoGenericContext *context, MonoError *error)
5405 {
5415 }
5417 /**
5418 * mono_bounded_array_class_get:
5419 * @element_class: element class
5420 * @rank: the dimension of the array class
5421 * @bounded: whenever the array has non-zero bounds
5422 *
5423 * Returns: a class object describing the array with element type @element_type and
5424 * dimension @rank.
5425 */
5426 MonoClass *
5428 {
5440 /* bounded only matters for one-dimensional arrays */
5446 /*
5447 * This case is very frequent not just during compilation because of calls
5448 * from mono_class_from_mono_type (), mono_array_new (),
5449 * Array:CreateInstance (), etc, so use a separate cache + a separate lock.
5450 */
5469 if ((class->rank == rank) && (class->byval_arg.type == (((rank > 1) || bounded) ? MONO_TYPE_ARRAY : MONO_TYPE_SZARRAY))) {
5472 }
5473 }
5474 }
5475 }
5477 /* for the building corlib use System.Array from it */
5478 if (image->assembly && image->assembly->dynamic && image->assembly_name && strcmp (image->assembly_name, "mscorlib") == 0) {
5485 }
5509 /* all arrays are marked serializable and sealed, bug #42779 */
5510 class->flags = TYPE_ATTRIBUTE_CLASS | TYPE_ATTRIBUTE_SERIALIZABLE | TYPE_ATTRIBUTE_SEALED | TYPE_ATTRIBUTE_PUBLIC;
5518 }
5519 /* element_size -1 is ok as this is not an instantitable type*/
5530 if (eclass->exception_type) /*FIXME we fail the array type, but we have to let other fields be set.*/
5533 class->has_references = MONO_TYPE_IS_REFERENCE (&eclass->byval_arg) || eclass->has_references? TRUE: FALSE;
5539 else
5550 /* FIXME: complete.... */
5554 }
5559 }
5569 /* Someone got in before us */
5571 else
5577 }
5584 }
5586 /**
5587 * mono_array_class_get:
5588 * @element_class: element class
5589 * @rank: the dimension of the array class
5590 *
5591 * Returns: a class object describing the array with element type @element_type and
5592 * dimension @rank.
5593 */
5594 MonoClass *
5596 {
5598 }
5600 /**
5601 * mono_class_instance_size:
5602 * @klass: a class
5603 *
5604 * Returns: the size of an object instance
5605 */
5606 gint32
5608 {
5613 }
5615 /**
5616 * mono_class_min_align:
5617 * @klass: a class
5618 *
5619 * Returns: minimm alignment requirements
5620 */
5621 gint32
5623 {
5628 }
5630 /**
5631 * mono_class_value_size:
5632 * @klass: a class
5633 *
5634 * This function is used for value types, and return the
5635 * space and the alignment to store that kind of value object.
5636 *
5637 * Returns: the size of a value of kind @klass
5638 */
5639 gint32
5641 {
5642 gint32 size;
5644 /* fixme: check disable, because we still have external revereces to
5645 * mscorlib and Dummy Objects
5646 */
5647 /*g_assert (klass->valuetype);*/
5655 }
5657 /**
5658 * mono_class_data_size:
5659 * @klass: a class
5660 *
5661 * Returns: the size of the static class data
5662 */
5663 gint32
5665 {
5669 /* in arrays, sizes.class_size is unioned with element_size
5670 * and arrays have no static fields
5671 */
5675 }
5677 /*
5678 * Auxiliary routine to mono_class_get_field
5679 *
5680 * Takes a field index instead of a field token.
5681 */
5684 {
5691 /*
5692 * class->field.first points to the FieldPtr table, while idx points into the
5693 * Field table, so we have to do a search.
5694 */
5695 /*FIXME this is broken for types with multiple fields with the same name.*/
5696 const char *name = mono_metadata_string_heap (class->image, mono_metadata_decode_row_col (&class->image->tables [MONO_TABLE_FIELD], idx, MONO_FIELD_NAME));
5707 }
5708 }
5709 }
5711 }
5713 }
5715 /**
5716 * mono_class_get_field:
5717 * @class: the class to lookup the field.
5718 * @field_token: the field token
5719 *
5720 * Returns: A MonoClassField representing the type and offset of
5721 * the field, or a NULL value if the field does not belong to this
5722 * class.
5723 */
5724 MonoClassField *
5726 {
5732 }
5734 /**
5735 * mono_class_get_field_from_name:
5736 * @klass: the class to lookup the field.
5737 * @name: the field name
5738 *
5739 * Search the class @klass and it's parents for a field with the name @name.
5740 *
5741 * Returns: the MonoClassField pointer of the named field or NULL
5742 */
5743 MonoClassField *
5745 {
5747 }
5749 /**
5750 * mono_class_get_field_from_name_full:
5751 * @klass: the class to lookup the field.
5752 * @name: the field name
5753 * @type: the type of the fields. This optional.
5754 *
5755 * Search the class @klass and it's parents for a field with the name @name and type @type.
5756 *
5757 * If @klass is an inflated generic type, the type comparison is done with the equivalent field
5758 * of its generic type definition.
5759 *
5760 * Returns: the MonoClassField pointer of the named field or NULL
5761 */
5762 MonoClassField *
5764 {
5779 MonoType *field_type = mono_metadata_get_corresponding_field_from_generic_type_definition (field)->type;
5782 }
5784 }
5786 }
5788 }
5790 /**
5791 * mono_class_get_field_token:
5792 * @field: the field we need the token of
5793 *
5794 * Get the token of a field. Note that the tokesn is only valid for the image
5795 * the field was loaded from. Don't use this function for fields in dynamic types.
5796 *
5797 * Returns: the token representing the field in the image it was loaded from.
5798 */
5799 guint32
5801 {
5817 }
5818 }
5820 }
5824 }
5826 static int
5828 {
5834 }
5836 /*
5837 * mono_class_get_field_default_value:
5838 *
5839 * Return the default value of the field as a pointer into the metadata blob.
5840 */
5843 {
5844 guint32 cindex;
5855 klass->ext->field_def_values = mono_image_alloc0 (klass->image, sizeof (MonoFieldDefaultValue) * klass->field.count);
5857 }
5862 cindex = mono_metadata_get_constant_index (field->parent->image, mono_class_get_field_token (field), 0);
5866 mono_metadata_decode_row (&field->parent->image->tables [MONO_TABLE_CONSTANT], cindex - 1, constant_cols, MONO_CONSTANT_SIZE);
5868 klass->ext->field_def_values [field_index].data = (gpointer)mono_metadata_blob_heap (field->parent->image, constant_cols [MONO_CONSTANT_VALUE]);
5869 }
5873 }
5875 guint32
5877 {
5886 }
5887 }
5889 }
5893 }
5895 MonoProperty*
5897 {
5904 }
5906 }
5908 }
5910 guint32
5912 {
5922 i ++;
5923 }
5925 }
5929 }
5933 {
5952 else
5954 }
5968 else
5970 }
5976 }
5977 }
5981 {
5990 MonoAssemblyName aname;
6003 /* FIXME: */
6006 /* FIXME: */
6009 /* FIXME: */
6016 }
6018 }
6020 /* FIXME: */
6024 }
6027 }
6029 /**
6030 * mono_class_get_full:
6031 * @image: the image where the class resides
6032 * @type_token: the token for the class
6033 * @context: the generic context used to evaluate generic instantiations in
6034 *
6035 * Returns: the MonoClass that represents @type_token in @image
6036 */
6037 MonoClass *
6039 {
6040 MonoError error;
6046 if (table != MONO_TABLE_TYPEDEF && table != MONO_TABLE_TYPEREF && table != MONO_TABLE_TYPESPEC) {
6049 }
6051 }
6063 /*FIXME don't swallow the error message*/
6065 }
6070 }
6076 }
6079 }
6082 /**
6083 * mono_type_get_full:
6084 * @image: the image where the type resides
6085 * @type_token: the token for the type
6086 * @context: the generic context used to evaluate generic instantiations in
6087 *
6088 * This functions exists to fullfill the fact that sometimes it's desirable to have access to the
6089 *
6090 * Returns: the MonoType that represents @type_token in @image
6091 */
6092 MonoType *
6094 {
6095 MonoError error;
6099 //FIXME: this will not fix the very issue for which mono_type_get_full exists -but how to do it then?
6106 }
6111 /*FIXME don't swalloc the error message.*/
6115 g_warning ("Error loading type %s from %s due to %s", name, assembly, mono_error_get_message (&error));
6120 }
6125 /* FIXME: This is a workaround fo the fact that a typespec token sometimes reference to the generic type definition.
6126 * A MonoClass::byval_arg of a generic type definion has type CLASS.
6127 * Some parts of mono create a GENERICINST to reference a generic type definition and this generates confict with byval_arg.
6128 *
6129 * The long term solution is to chaise this places and make then set MonoType::type correctly.
6130 * */
6133 else
6135 }
6137 }
6140 MonoClass *
6142 {
6144 }
6146 /**
6147 * mono_image_init_name_cache:
6148 *
6149 * Initializes the class name cache stored in image->name_cache.
6150 *
6151 * LOCKING: Acquires the corresponding image lock.
6152 */
6153 void
6155 {
6168 }
6175 }
6177 /* Temporary hash table to avoid lookups in the nspace_table */
6183 /*
6184 * Nested types are accessed from the nesting name. We use the fact that nested types use different visibility flags
6185 * than toplevel types, thus avoiding the need to grovel through the NESTED_TYPE table
6186 */
6198 nspace_table);
6199 }
6201 }
6203 /* Load type names from EXPORTEDTYPES table */
6204 {
6220 nspace_table);
6221 }
6222 g_hash_table_insert (nspace_table, (char *) name, GUINT_TO_POINTER (mono_metadata_make_token (MONO_TABLE_EXPORTEDTYPE, i + 1)));
6223 }
6224 }
6228 }
6230 /*FIXME Only dynamic assemblies should allow this operation.*/
6231 void
6234 {
6237 guint32 old_index;
6248 }
6251 g_error ("overrwritting old token %x on image %s for type %s::%s", old_index, image->name, nspace, name);
6256 }
6259 gconstpointer key;
6260 gpointer value;
6263 static void
6265 {
6271 }
6273 /**
6274 * mono_class_from_name_case:
6275 * @image: The MonoImage where the type is looked up in
6276 * @name_space: the type namespace
6277 * @name: the type short name.
6278 *
6279 * Obtains a MonoClass with a given namespace and a given name which
6280 * is located in the given MonoImage. The namespace and name
6281 * lookups are case insensitive.
6282 */
6283 MonoClass *
6285 {
6294 FindUserData user_data;
6315 }
6321 else
6324 }
6326 /* add a cache if needed */
6330 /*
6331 * Nested types are accessed from the nesting name. We use the fact that nested types use different visibility flags
6332 * than toplevel types, thus avoiding the need to grovel through the NESTED_TYPE table
6333 */
6340 }
6342 }
6346 {
6353 s++;
6354 }
6361 }
6362 }
6364 }
6368 {
6374 /*
6375 * The EXPORTEDTYPES table only contains public types, so have to search the
6376 * modules as well.
6377 * Note: image->modules contains the contents of the MODULEREF table, while
6378 * the real module list is in the FILE table.
6379 */
6391 }
6392 }
6395 }
6397 /**
6398 * mono_class_from_name:
6399 * @image: The MonoImage where the type is looked up in
6400 * @name_space: the type namespace
6401 * @name: the type short name.
6402 *
6403 * Obtains a MonoClass with a given namespace and a given name which
6404 * is located in the given MonoImage.
6405 */
6406 MonoClass *
6408 {
6426 }
6435 else
6437 }
6438 }
6453 /* Search modules as well */
6460 }
6461 }
6467 }
6491 guint32 assembly_idx;
6499 else
6500 /* FIXME: Cycle detection */
6504 }
6505 }
6513 }
6515 /*FIXME test for interfaces with variant generic arguments*/
6516 gboolean
6518 gboolean check_interfaces)
6519 {
6521 if (check_interfaces && MONO_CLASS_IS_INTERFACE (klassc) && !MONO_CLASS_IS_INTERFACE (klass)) {
6524 } else if (check_interfaces && MONO_CLASS_IS_INTERFACE (klassc) && MONO_CLASS_IS_INTERFACE (klass)) {
6531 }
6535 }
6537 /*
6538 * MS.NET thinks interfaces are a subclass of Object, so we think it as
6539 * well.
6540 */
6545 }
6547 gboolean
6549 {
6559 if (mono_generic_container_get_param_info (container, i)->flags & (MONO_GEN_PARAM_VARIANT|MONO_GEN_PARAM_COVARIANT))
6563 }
6565 /**
6566 * @container the generic container from the GTD
6567 * @klass: the class to be assigned to
6568 * @oklass: the source class
6569 *
6570 * Both klass and oklass must be instances of the same generic interface.
6571 * Return true if @klass can be assigned to a @klass variable
6572 */
6573 static gboolean
6575 {
6581 /*Viable candidates are instances of the same generic interface*/
6595 /*
6596 * The _VARIANT and _COVARIANT constants should read _COVARIANT and
6597 * _CONTRAVARIANT, but they are in a public header so we can't fix it.
6598 */
6603 } else if (mono_generic_container_get_param_info (container, j)->flags & MONO_GEN_PARAM_COVARIANT) {
6608 }
6609 }
6611 }
6613 /**
6614 * mono_class_is_assignable_from:
6615 * @klass: the class to be assigned to
6616 * @oklass: the source class
6617 *
6618 * Return: true if an instance of object oklass can be assigned to an
6619 * instance of object @klass
6620 */
6621 gboolean
6623 {
6637 /* interface_offsets might not be set for dynamic classes */
6639 /*
6640 * oklass might be a generic type parameter but they have
6641 * interface_offsets set.
6642 */
6645 /* Happens with generic instances of not-yet created dynamic types */
6654 /*klass is a generic variant interface, We need to extract from oklass a list of ifaces which are viable candidates.*/
6660 }
6661 }
6664 if (mono_class_has_variant_generic_params (klass) && mono_class_is_variant_compatible (klass, oklass))
6672 /* vectors vs. one dimensional arrays */
6679 /*
6680 * a is b does not imply a[] is b[] when a is a valuetype, and
6681 * b is a reference type.
6682 */
6689 }
6695 else
6701 }
6703 /*Check if @oklass is variant compatible with @klass.*/
6704 static gboolean
6706 {
6712 /*Viable candidates are instances of the same generic interface*/
6726 /*
6727 * The _VARIANT and _COVARIANT constants should read _COVARIANT and
6728 * _CONTRAVARIANT, but they are in a public header so we can't fix it.
6729 */
6734 } else if (mono_generic_container_get_param_info (container, j)->flags & MONO_GEN_PARAM_COVARIANT) {
6739 }
6740 }
6742 }
6743 /*Check if @candidate implements the interface @target*/
6744 static gboolean
6746 {
6753 }
6759 /*A TypeBuilder can have more interfaces on tb->interfaces than on candidate->interfaces*/
6773 }
6774 }
6776 /*setup_interfaces don't mono_class_init anything*/
6787 }
6788 }
6793 }
6795 /*
6796 * Check if @oklass can be assigned to @klass.
6797 * This function does the same as mono_class_is_assignable_from but is safe to be used from mono_class_init context.
6798 */
6799 gboolean
6801 {
6807 /*setup_supertypes don't mono_class_init anything */
6814 /*If target is not an interface there is no need to check them.*/
6821 /*FIXME properly handle nullables and arrays */
6824 }
6826 /**
6827 * mono_class_get_cctor:
6828 * @klass: A MonoClass pointer
6829 *
6830 * Returns: the static constructor of @klass if it exists, NULL otherwise.
6831 */
6832 MonoMethod*
6834 {
6835 MonoCachedClassInfo cached_info;
6844 return mono_class_get_inflated_method (klass, mono_class_get_cctor (klass->generic_class->container_class));
6846 return mono_class_get_method_from_name_flags (klass, ".cctor", -1, METHOD_ATTRIBUTE_SPECIAL_NAME);
6847 }
6849 /**
6850 * mono_class_get_finalizer:
6851 * @klass: The MonoClass pointer
6852 *
6853 * Returns: the finalizer method of @klass if it exists, NULL otherwise.
6854 */
6855 MonoMethod*
6857 {
6858 MonoCachedClassInfo cached_info;
6870 }
6871 }
6873 /**
6874 * mono_class_needs_cctor_run:
6875 * @klass: the MonoClass pointer
6876 * @caller: a MonoMethod describing the caller
6877 *
6878 * Determines whenever the class has a static constructor and whenever it
6879 * needs to be called when executing CALLER.
6880 */
6881 gboolean
6883 {
6889 else
6891 }
6893 /**
6894 * mono_class_array_element_size:
6895 * @klass:
6896 *
6897 * Returns: the number of bytes an element of type @klass
6898 * uses when stored into an array.
6899 */
6900 gint32
6902 {
6905 handle_enum:
6939 }
6950 }
6952 }
6954 /**
6955 * mono_array_element_size:
6956 * @ac: pointer to a #MonoArrayClass
6957 *
6958 * Returns: the size of single array element.
6959 */
6960 gint32
6962 {
6965 }
6967 gpointer
6970 {
6973 gpointer obj = mono_lookup_dynamic_token_class (image, token, TRUE, &tmp_handle_class, context);
6981 else
6983 }
6996 /* We return a MonoType* as handle */
6998 }
7011 }
7019 }
7023 mono_metadata_decode_row (&image->tables [MONO_TABLE_MEMBERREF], mono_metadata_token_index (token) - 1, cols, MONO_MEMBERREF_SIZE);
7039 }
7040 }
7044 }
7046 }
7048 /**
7049 * This function might need to call runtime functions so it can't be part
7050 * of the metadata library.
7051 */
7054 void
7056 {
7058 }
7060 gpointer
7062 {
7066 }
7068 gpointer
7069 mono_lookup_dynamic_token_class (MonoImage *image, guint32 token, gboolean valid_token, MonoClass **handle_class, MonoGenericContext *context)
7070 {
7072 }
7076 void
7078 {
7080 }
7082 static gboolean
7084 {
7087 else
7089 }
7091 void
7093 {
7095 }
7097 MonoImage*
7099 {
7101 }
7103 /**
7104 * mono_class_get_element_class:
7105 * @klass: the MonoClass to act on
7106 *
7107 * Returns: the element class of an array or an enumeration.
7108 */
7109 MonoClass*
7111 {
7113 }
7115 /**
7116 * mono_class_is_valuetype:
7117 * @klass: the MonoClass to act on
7118 *
7119 * Returns: true if the MonoClass represents a ValueType.
7120 */
7121 gboolean
7123 {
7125 }
7127 /**
7128 * mono_class_is_enum:
7129 * @klass: the MonoClass to act on
7130 *
7131 * Returns: true if the MonoClass represents an enumeration.
7132 */
7133 gboolean
7135 {
7137 }
7139 /**
7140 * mono_class_enum_basetype:
7141 * @klass: the MonoClass to act on
7142 *
7143 * Returns: the underlying type representation for an enumeration.
7144 */
7145 MonoType*
7147 {
7149 /* SRE or broken types */
7151 else
7153 }
7155 /**
7156 * mono_class_get_parent
7157 * @klass: the MonoClass to act on
7158 *
7159 * Returns: the parent class for this class.
7160 */
7161 MonoClass*
7163 {
7165 }
7167 /**
7168 * mono_class_get_nesting_type;
7169 * @klass: the MonoClass to act on
7170 *
7171 * Returns: the container type where this type is nested or NULL if this type is not a nested type.
7172 */
7173 MonoClass*
7175 {
7177 }
7179 /**
7180 * mono_class_get_rank:
7181 * @klass: the MonoClass to act on
7182 *
7183 * Returns: the rank for the array (the number of dimensions).
7184 */
7185 int
7187 {
7189 }
7191 /**
7192 * mono_class_get_flags:
7193 * @klass: the MonoClass to act on
7194 *
7195 * The type flags from the TypeDef table from the metadata.
7196 * see the TYPE_ATTRIBUTE_* definitions on tabledefs.h for the
7197 * different values.
7198 *
7199 * Returns: the flags from the TypeDef table.
7200 */
7201 guint32
7203 {
7205 }
7207 /**
7208 * mono_class_get_name
7209 * @klass: the MonoClass to act on
7210 *
7211 * Returns: the name of the class.
7212 */
7215 {
7217 }
7219 /**
7220 * mono_class_get_namespace:
7221 * @klass: the MonoClass to act on
7222 *
7223 * Returns: the namespace of the class.
7224 */
7227 {
7229 }
7231 /**
7232 * mono_class_get_type:
7233 * @klass: the MonoClass to act on
7234 *
7235 * This method returns the internal Type representation for the class.
7236 *
7237 * Returns: the MonoType from the class.
7238 */
7239 MonoType*
7241 {
7243 }
7245 /**
7246 * mono_class_get_type_token
7247 * @klass: the MonoClass to act on
7248 *
7249 * This method returns type token for the class.
7250 *
7251 * Returns: the type token for the class.
7252 */
7253 guint32
7255 {
7257 }
7259 /**
7260 * mono_class_get_byref_type:
7261 * @klass: the MonoClass to act on
7262 *
7263 *
7264 */
7265 MonoType*
7267 {
7269 }
7271 /**
7272 * mono_class_num_fields:
7273 * @klass: the MonoClass to act on
7274 *
7275 * Returns: the number of static and instance fields in the class.
7276 */
7277 int
7279 {
7281 }
7283 /**
7284 * mono_class_num_methods:
7285 * @klass: the MonoClass to act on
7286 *
7287 * Returns: the number of methods in the class.
7288 */
7289 int
7291 {
7293 }
7295 /**
7296 * mono_class_num_properties
7297 * @klass: the MonoClass to act on
7298 *
7299 * Returns: the number of properties in the class.
7300 */
7301 int
7303 {
7307 }
7309 /**
7310 * mono_class_num_events:
7311 * @klass: the MonoClass to act on
7312 *
7313 * Returns: the number of events in the class.
7314 */
7315 int
7317 {
7321 }
7323 /**
7324 * mono_class_get_fields:
7325 * @klass: the MonoClass to act on
7326 *
7327 * This routine is an iterator routine for retrieving the fields in a class.
7328 *
7329 * You must pass a gpointer that points to zero and is treated as an opaque handle to
7330 * iterate over all of the elements. When no more values are
7331 * available, the return value is NULL.
7332 *
7333 * Returns: a @MonoClassField* on each iteration, or NULL when no more fields are available.
7334 */
7335 MonoClassField*
7337 {
7345 /* start from the first */
7349 /* no fields */
7351 }
7352 }
7354 field++;
7357 }
7359 }
7361 /**
7362 * mono_class_get_methods
7363 * @klass: the MonoClass to act on
7364 *
7365 * This routine is an iterator routine for retrieving the fields in a class.
7366 *
7367 * You must pass a gpointer that points to zero and is treated as an opaque handle to
7368 * iterate over all of the elements. When no more values are
7369 * available, the return value is NULL.
7370 *
7371 * Returns: a MonoMethod on each iteration or NULL when no more methods are available.
7372 */
7373 MonoMethod*
7375 {
7384 /*
7385 * We can't fail lookup of methods otherwise the runtime will burst in flames on all sort of places.
7386 * FIXME we should better report this error to the caller
7387 */
7390 /* start from the first */
7395 /* no method */
7397 }
7398 }
7400 method++;
7404 }
7406 }
7408 /*
7409 * mono_class_get_virtual_methods:
7410 *
7411 * Iterate over the virtual methods of KLASS.
7412 *
7413 * LOCKING: Assumes the loader lock is held (because of the klass->methods check).
7414 */
7417 {
7421 if (klass->methods || !MONO_CLASS_HAS_STATIC_METADATA (klass) || mono_debug_using_mono_debugger ()) {
7424 /*
7425 * We can't fail lookup of methods otherwise the runtime will burst in flames on all sort of places.
7426 * FIXME we should better report this error to the caller
7427 */
7430 /* start from the first */
7434 method++;
7435 }
7439 method ++;
7440 }
7446 }
7448 /* Search directly in metadata to avoid calling setup_methods () */
7456 }
7459 guint32 flags;
7461 /* class->method.first points into the methodptr table */
7462 flags = mono_metadata_decode_table_row_col (klass->image, MONO_TABLE_METHOD, klass->method.first + i, MONO_METHOD_FLAGS);
7466 }
7469 res = mono_get_method (klass->image, MONO_TOKEN_METHOD_DEF | (klass->method.first + i + 1), klass);
7470 /* Add 1 here so the if (*iter) check fails */
7475 }
7476 }
7477 }
7479 /**
7480 * mono_class_get_properties:
7481 * @klass: the MonoClass to act on
7482 *
7483 * This routine is an iterator routine for retrieving the properties in a class.
7484 *
7485 * You must pass a gpointer that points to zero and is treated as an opaque handle to
7486 * iterate over all of the elements. When no more values are
7487 * available, the return value is NULL.
7488 *
7489 * Returns: a @MonoProperty* on each invocation, or NULL when no more are available.
7490 */
7491 MonoProperty*
7493 {
7501 /* start from the first */
7505 /* no fields */
7507 }
7508 }
7510 property++;
7513 }
7515 }
7517 /**
7518 * mono_class_get_events:
7519 * @klass: the MonoClass to act on
7520 *
7521 * This routine is an iterator routine for retrieving the properties in a class.
7522 *
7523 * You must pass a gpointer that points to zero and is treated as an opaque handle to
7524 * iterate over all of the elements. When no more values are
7525 * available, the return value is NULL.
7526 *
7527 * Returns: a @MonoEvent* on each invocation, or NULL when no more are available.
7528 */
7529 MonoEvent*
7531 {
7539 /* start from the first */
7543 /* no fields */
7545 }
7546 }
7548 event++;
7551 }
7553 }
7555 /**
7556 * mono_class_get_interfaces
7557 * @klass: the MonoClass to act on
7558 *
7559 * This routine is an iterator routine for retrieving the interfaces implemented by this class.
7560 *
7561 * You must pass a gpointer that points to zero and is treated as an opaque handle to
7562 * iterate over all of the elements. When no more values are
7563 * available, the return value is NULL.
7564 *
7565 * Returns: a @Monoclass* on each invocation, or NULL when no more are available.
7566 */
7567 MonoClass*
7569 {
7578 /* start from the first */
7583 /* no interface */
7585 }
7586 }
7588 iface++;
7592 }
7594 }
7596 /**
7597 * mono_class_get_nested_types
7598 * @klass: the MonoClass to act on
7599 *
7600 * This routine is an iterator routine for retrieving the nested types of a class.
7601 * This works only if @klass is non-generic, or a generic type definition.
7602 *
7603 * You must pass a gpointer that points to zero and is treated as an opaque handle to
7604 * iterate over all of the elements. When no more values are
7605 * available, the return value is NULL.
7606 *
7607 * Returns: a @Monoclass* on each invocation, or NULL when no more are available.
7608 */
7609 MonoClass*
7611 {
7628 mono_metadata_decode_row (&klass->image->tables [MONO_TABLE_NESTEDCLASS], i - 1, cols, MONO_NESTED_CLASS_SIZE);
7629 nclass = mono_class_create_from_typedef (klass->image, MONO_TOKEN_TYPE_DEF | cols [MONO_NESTED_CLASS_NESTED]);
7633 klass->ext->nested_classes = g_list_prepend_image (klass->image, klass->ext->nested_classes, nclass);
7636 }
7637 }
7641 }
7644 /* start from the first */
7649 /* no nested types */
7651 }
7652 }
7658 }
7660 }
7662 /**
7663 * mono_field_get_name:
7664 * @field: the MonoClassField to act on
7665 *
7666 * Returns: the name of the field.
7667 */
7670 {
7672 }
7674 /**
7675 * mono_field_get_type:
7676 * @field: the MonoClassField to act on
7677 *
7678 * Returns: MonoType of the field.
7679 */
7680 MonoType*
7682 {
7684 }
7686 /**
7687 * mono_field_get_parent:
7688 * @field: the MonoClassField to act on
7689 *
7690 * Returns: MonoClass where the field was defined.
7691 */
7692 MonoClass*
7694 {
7696 }
7698 /**
7699 * mono_field_get_flags;
7700 * @field: the MonoClassField to act on
7701 *
7702 * The metadata flags for a field are encoded using the
7703 * FIELD_ATTRIBUTE_* constants. See the tabledefs.h file for details.
7704 *
7705 * Returns: the flags for the field.
7706 */
7707 guint32
7709 {
7711 }
7713 /**
7714 * mono_field_get_offset;
7715 * @field: the MonoClassField to act on
7716 *
7717 * Returns: the field offset.
7718 */
7719 guint32
7721 {
7723 }
7727 {
7728 guint32 rva;
7738 klass->ext->field_def_values = mono_image_alloc0 (klass->image, sizeof (MonoFieldDefaultValue) * klass->field.count);
7740 }
7745 mono_metadata_field_info (field->parent->image, klass->field.first + field_index, NULL, &rva, NULL);
7747 g_warning ("field %s in %s should have RVA data, but hasn't", mono_field_get_name (field), field->parent->name);
7748 klass->ext->field_def_values [field_index].data = mono_image_rva_map (field->parent->image, rva);
7749 }
7752 }
7754 /**
7755 * mono_field_get_data;
7756 * @field: the MonoClassField to act on
7757 *
7758 * Returns: pointer to the metadata constant value or to the field
7759 * data if it has an RVA flag.
7760 */
7763 {
7765 MonoTypeEnum def_type;
7772 }
7773 }
7775 /**
7776 * mono_property_get_name:
7777 * @prop: the MonoProperty to act on
7778 *
7779 * Returns: the name of the property
7780 */
7783 {
7785 }
7787 /**
7788 * mono_property_get_set_method
7789 * @prop: the MonoProperty to act on.
7790 *
7791 * Returns: the setter method of the property (A MonoMethod)
7792 */
7793 MonoMethod*
7795 {
7797 }
7799 /**
7800 * mono_property_get_get_method
7801 * @prop: the MonoProperty to act on.
7802 *
7803 * Returns: the setter method of the property (A MonoMethod)
7804 */
7805 MonoMethod*
7807 {
7809 }
7811 /**
7812 * mono_property_get_parent:
7813 * @prop: the MonoProperty to act on.
7814 *
7815 * Returns: the MonoClass where the property was defined.
7816 */
7817 MonoClass*
7819 {
7821 }
7823 /**
7824 * mono_property_get_flags:
7825 * @prop: the MonoProperty to act on.
7826 *
7827 * The metadata flags for a property are encoded using the
7828 * PROPERTY_ATTRIBUTE_* constants. See the tabledefs.h file for details.
7829 *
7830 * Returns: the flags for the property.
7831 */
7832 guint32
7834 {
7836 }
7838 /**
7839 * mono_event_get_name:
7840 * @event: the MonoEvent to act on
7841 *
7842 * Returns: the name of the event.
7843 */
7846 {
7848 }
7850 /**
7851 * mono_event_get_add_method:
7852 * @event: The MonoEvent to act on.
7853 *
7854 * Returns: the @add' method for the event (a MonoMethod).
7855 */
7856 MonoMethod*
7858 {
7860 }
7862 /**
7863 * mono_event_get_remove_method:
7864 * @event: The MonoEvent to act on.
7865 *
7866 * Returns: the @remove method for the event (a MonoMethod).
7867 */
7868 MonoMethod*
7870 {
7872 }
7874 /**
7875 * mono_event_get_raise_method:
7876 * @event: The MonoEvent to act on.
7877 *
7878 * Returns: the @raise method for the event (a MonoMethod).
7879 */
7880 MonoMethod*
7882 {
7884 }
7886 /**
7887 * mono_event_get_parent:
7888 * @event: the MonoEvent to act on.
7889 *
7890 * Returns: the MonoClass where the event is defined.
7891 */
7892 MonoClass*
7894 {
7896 }
7898 /**
7899 * mono_event_get_flags
7900 * @event: the MonoEvent to act on.
7901 *
7902 * The metadata flags for an event are encoded using the
7903 * EVENT_* constants. See the tabledefs.h file for details.
7904 *
7905 * Returns: the flags for the event.
7906 */
7907 guint32
7909 {
7911 }
7913 /**
7914 * mono_class_get_method_from_name:
7915 * @klass: where to look for the method
7916 * @name_space: name of the method
7917 * @param_count: number of parameters. -1 for any number.
7918 *
7919 * Obtains a MonoMethod with a given name and number of parameters.
7920 * It only works if there are no multiple signatures for any given method name.
7921 */
7922 MonoMethod *
7924 {
7926 }
7930 {
7934 /* Search directly in the metadata to avoid calling setup_methods () */
7939 /* class->method.first points into the methodptr table */
7940 mono_metadata_decode_table_row (klass->image, MONO_TABLE_METHOD, klass->method.first + i, cols, MONO_METHOD_SIZE);
7943 method = mono_get_method (klass->image, MONO_TOKEN_METHOD_DEF | (klass->method.first + i + 1), klass);
7947 }
7948 }
7949 }
7952 }
7954 /**
7955 * mono_class_get_method_from_name_flags:
7956 * @klass: where to look for the method
7957 * @name_space: name of the method
7958 * @param_count: number of parameters. -1 for any number.
7959 * @flags: flags which must be set in the method
7960 *
7961 * Obtains a MonoMethod with a given name and number of parameters.
7962 * It only works if there are no multiple signatures for any given method name.
7963 */
7964 MonoMethod *
7965 mono_class_get_method_from_name_flags (MonoClass *klass, const char *name, int param_count, int flags)
7966 {
7973 res = mono_class_get_method_from_name_flags (klass->generic_class->container_class, name, param_count, flags);
7977 }
7981 /*
7982 We can't fail lookup of methods otherwise the runtime will burst in flames on all sort of places.
7983 See mono/tests/array_load_exception.il
7984 FIXME we should better report this error to the caller
7985 */
7997 }
7998 }
7999 }
8002 }
8005 }
8007 /**
8008 * mono_class_set_failure:
8009 * @klass: class in which the failure was detected
8010 * @ex_type: the kind of exception/error to be thrown (later)
8011 * @ex_data: exception data (specific to each type of exception/error)
8012 *
8013 * Keep a detected failure informations in the class for later processing.
8014 * Note that only the first failure is kept.
8015 *
8016 * LOCKING: Acquires the loader lock.
8017 */
8018 gboolean
8020 {
8031 }
8033 /*
8034 * mono_class_get_exception_data:
8035 *
8036 * Return the exception_data property of KLASS.
8037 *
8038 * LOCKING: Acquires the loader lock.
8039 */
8040 gpointer
8042 {
8044 }
8046 /**
8047 * mono_classes_init:
8048 *
8049 * Initialize the resources used by this module.
8050 */
8051 void
8053 {
8064 }
8066 /**
8067 * mono_classes_cleanup:
8068 *
8069 * Free the resources used by this module.
8070 */
8071 void
8073 {
8076 }
8078 /**
8079 * mono_class_get_exception_for_failure:
8080 * @klass: class in which the failure was detected
8081 *
8082 * Return a constructed MonoException than the caller can then throw
8083 * using mono_raise_exception - or NULL if no failure is present (or
8084 * doesn't result in an exception).
8085 */
8086 MonoException*
8088 {
8096 guint32 error = (method) ? MONO_METADATA_INHERITANCEDEMAND_METHOD : MONO_METADATA_INHERITANCEDEMAND_CLASS;
8107 }
8112 char *astr = klass->image->assembly? mono_stringify_assembly_name (&klass->image->assembly->aname): NULL;
8118 }
8124 }
8130 }
8137 ex = mono_get_exception_file_not_found2 (msg, mono_string_new (mono_domain_get (), assembly_name));
8142 }
8145 }
8154 }
8156 /* TODO - handle other class related failures */
8158 }
8159 }
8160 }
8162 static gboolean
8164 {
8173 }
8175 MonoClass *
8177 {
8179 }
8181 /*
8182 * Check if @klass is a subtype of @parent ignoring generic instantiations.
8183 *
8184 * Generic instantiations are ignored for all super types of @klass.
8185 *
8186 * Visibility checks ignoring generic instantiations.
8187 */
8188 gboolean
8190 {
8198 }
8200 }
8201 /*
8202 * Subtype can only access parent members with family protection if the site object
8203 * is subclass of Subtype. For example:
8204 * class A { protected int x; }
8205 * class B : A {
8206 * void valid_access () {
8207 * B b;
8208 * b.x = 0;
8209 * }
8210 * void invalid_access () {
8211 * A a;
8212 * a.x = 0;
8213 * }
8214 * }
8215 * */
8216 static gboolean
8217 is_valid_family_access (MonoClass *access_klass, MonoClass *member_klass, MonoClass *context_klass)
8218 {
8224 /*if access_klass is not member_klass context_klass must be type compat*/
8225 if (access_klass != member_klass && !mono_class_has_parent_and_ignore_generics (context_klass, access_klass))
8228 }
8230 static gboolean
8232 {
8239 /* extra safety under CoreCLR - the runtime does not verify the strongname signatures
8240 * anywhere so untrusted friends are not safe to access platform's code internals */
8244 }
8249 /* Be conservative with checks */
8257 if (!mono_public_tokens_are_equal (friend->public_key_token, accessing->aname.public_key_token))
8259 }
8261 }
8263 }
8265 /*
8266 * If klass is a generic type or if it is derived from a generic type, return the
8267 * MonoClass of the generic definition
8268 * Returns NULL if not found
8269 */
8272 {
8277 }
8279 }
8281 static gboolean
8283 {
8305 }
8306 }
8308 }
8310 static gboolean
8312 {
8323 if (member_klass->byval_arg.type == MONO_TYPE_VAR || member_klass->byval_arg.type == MONO_TYPE_MVAR)
8326 if (member_klass->generic_class && !can_access_instantiation (access_klass, member_klass->generic_class->context.class_inst))
8329 if (is_nesting_type (access_klass, member_klass) || (access_klass->nested_in && is_nesting_type (access_klass->nested_in, member_klass)))
8335 /*Non nested type with nested visibility. We just fail it.*/
8336 if (access_level >= TYPE_ATTRIBUTE_NESTED_PRIVATE && access_level <= TYPE_ATTRIBUTE_NESTED_FAM_OR_ASSEM && member_klass->nested_in == NULL)
8359 return can_access_internals (access_klass->image->assembly, member_klass->nested_in->image->assembly) &&
8363 return can_access_internals (access_klass->image->assembly, member_klass->nested_in->image->assembly) ||
8365 }
8367 }
8369 /* FIXME: check visibility of type, too */
8370 static gboolean
8371 can_access_member (MonoClass *access_klass, MonoClass *member_klass, MonoClass* context_klass, int access_level)
8372 {
8381 else
8386 }
8388 /* Partition I 8.5.3.2 */
8389 /* the access level values are the same for fields and methods */
8392 /* same compilation unit */
8413 }
8415 }
8417 gboolean
8419 {
8420 /* FIXME: check all overlapping fields */
8421 int can = can_access_member (method->klass, field->parent, NULL, field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK);
8425 can = can_access_member (nested, field->parent, NULL, field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK);
8429 }
8430 }
8432 }
8434 gboolean
8436 {
8437 int can = can_access_member (method->klass, called->klass, NULL, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
8441 can = can_access_member (nested, called->klass, NULL, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
8445 }
8446 }
8447 /*
8448 * FIXME:
8449 * with generics calls to explicit interface implementations can be expressed
8450 * directly: the method is private, but we must allow it. This may be opening
8451 * a hole or the generics code should handle this differently.
8452 * Maybe just ensure the interface type is public.
8453 */
8457 }
8459 /*
8460 * mono_method_can_access_method_full:
8461 * @method: The caller method
8462 * @called: The called method
8463 * @context_klass: The static type on stack of the owner @called object used
8464 *
8465 * This function must be used with instance calls, as they have more strict family accessibility.
8466 * It can be used with static methods, but context_klass should be NULL.
8467 *
8468 * Returns: TRUE if caller have proper visibility and acessibility to @called
8469 */
8470 gboolean
8471 mono_method_can_access_method_full (MonoMethod *method, MonoMethod *called, MonoClass *context_klass)
8472 {
8475 int can = can_access_member (access_class, member_class, context_klass, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
8479 can = can_access_member (nested, member_class, context_klass, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
8483 }
8484 }
8489 if (!can_access_type (access_class, member_class) && (!access_class->nested_in || !can_access_type (access_class->nested_in, member_class)))
8494 if (infl->context.method_inst && !can_access_instantiation (access_class, infl->context.method_inst))
8496 }
8499 }
8502 /*
8503 * mono_method_can_access_field_full:
8504 * @method: The caller method
8505 * @field: The accessed field
8506 * @context_klass: The static type on stack of the owner @field object used
8507 *
8508 * This function must be used with instance fields, as they have more strict family accessibility.
8509 * It can be used with static fields, but context_klass should be NULL.
8510 *
8511 * Returns: TRUE if caller have proper visibility and acessibility to @field
8512 */
8513 gboolean
8514 mono_method_can_access_field_full (MonoMethod *method, MonoClassField *field, MonoClass *context_klass)
8515 {
8518 /* FIXME: check all overlapping fields */
8519 int can = can_access_member (access_class, member_class, context_klass, field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK);
8523 can = can_access_member (nested, member_class, context_klass, field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK);
8527 }
8528 }
8533 if (!can_access_type (access_class, member_class) && (!access_class->nested_in || !can_access_type (access_class->nested_in, member_class)))
8536 }
8538 /**
8539 * mono_type_is_valid_enum_basetype:
8540 * @type: The MonoType to check
8541 *
8542 * Returns: TRUE if the type can be used as the basetype of an enum
8543 */
8559 }
8561 }
8563 /**
8564 * mono_class_is_valid_enum:
8565 * @klass: An enum class to be validated
8566 *
8567 * This method verify the required properties an enum should have.
8568 *
8569 * Returns: TRUE if the informed enum class is valid
8570 *
8571 * FIXME: TypeBuilder enums are allowed to implement interfaces, but since they cannot have methods, only empty interfaces are possible
8572 * FIXME: enum types are not allowed to have a cctor, but mono_reflection_create_runtime_class sets has_cctor to 1 for all types
8573 * FIXME: TypeBuilder enums can have any kind of static fields, but the spec is very explicit about that (P II 14.3)
8574 */
8581 /* we cannot test against mono_defaults.enum_class, or mcs won't be able to compile the System namespace*/
8582 if (!klass->parent || strcmp (klass->parent->name, "Enum") || strcmp (klass->parent->name_space, "System") ) {
8584 }
8596 }
8597 }
8606 }
8608 gboolean
8610 {
8611 return gklass->context.class_inst == gklass->container_class->generic_container->context.class_inst;
8612 }
8616 void
8618 {
8620 }
8622 /*
8623 * mono_class_generic_sharing_enabled:
8624 * @class: a class
8625 *
8626 * Returns whether generic sharing is enabled for class.
8627 *
8628 * This is a stop-gap measure to slowly introduce generic sharing
8629 * until we have all the issues sorted out, at which time this
8630 * function will disappear and generic sharing will always be enabled.
8631 */
8632 gboolean
8634 {
8643 else
8655 else
8657 }
8663 }
8680 }
8682 }
8684 /*
8685 * mono_class_setup_interface_id:
8686 *
8687 * Initializes MonoClass::interface_id if required.
8688 *
8689 * LOCKING: Acquires the loader lock.
8690 */
8691 void
8693 {
8698 }
8700 /*
8701 * mono_class_alloc_ext:
8702 *
8703 * Allocate klass->ext if not already done.
8704 * LOCKING: Assumes the loader lock is held.
8705 */
8706 void
8708 {
8714 }
8716 }
8717 }
8719 /*
8720 * mono_class_setup_interfaces:
8721 *
8722 * Initialize class->interfaces/interfaces_count.
8723 * LOCKING: Acquires the loader lock.
8724 */
8725 void
8727 {
8738 }
8740 if (klass->rank == 1 && klass->byval_arg.type != MONO_TYPE_ARRAY && mono_defaults.generic_ilist_class) {
8743 /* generic IList, ICollection, IEnumerable */
8745 klass->interfaces = mono_image_alloc0 (klass->image, sizeof (MonoClass*) * klass->interface_count);
8756 klass->interfaces [i] = mono_class_inflate_generic_class (gklass->interfaces [i], mono_generic_class_get_context (klass->generic_class));
8757 }
8764 }