| blob | fc52fc41a6909d09e8bb08b44d392021c7e279ff |
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 /* Statistics */
53 /* Function supplied by the runtime to find classes by name using information from the AOT file */
59 static MonoMethod* find_method_in_metadata (MonoClass *klass, const char *name, int param_count, int flags);
61 static void setup_generic_array_ifaces (MonoClass *class, MonoClass *iface, MonoMethod **methods, int pos);
71 /*
72 * mono_class_from_typeref:
73 * @image: a MonoImage
74 * @type_token: a TypeRef token
75 *
76 * Creates the MonoClass* structure representing the type defined by
77 * the typeref token valid inside @image.
78 * Returns: the MonoClass* representing the typeref token, NULL ifcould
79 * not be loaded.
80 */
81 MonoClass *
83 {
86 guint32 idx;
101 /* a typedef in disguise */
117 }
123 mono_loader_set_error_bad_image (g_strdup_printf ("Image %s with self-referencing typeref token %08x.", image->name, type_token));
125 }
132 /* Micro-optimization: don't scan the metadata tables if enclosing is already inited */
137 }
139 /* Don't call mono_class_init as we might've been called by it recursively */
142 guint32 class_nested = mono_metadata_decode_row_col (&enclosing->image->tables [MONO_TABLE_NESTEDCLASS], i - 1, MONO_NESTED_CLASS_NESTED);
143 guint32 string_offset = mono_metadata_decode_row_col (&enclosing->image->tables [MONO_TABLE_TYPEDEF], class_nested - 1, MONO_TYPEDEF_NAME);
150 }
151 }
152 g_warning ("TypeRef ResolutionScope not yet handled (%d) for %s.%s in image %s", idx, nspace, name, image->name);
154 }
157 }
160 mono_loader_set_error_bad_image (g_strdup_printf ("Image %s with invalid assemblyref token %08x.", image->name, idx));
162 }
168 /* If the assembly did not load, register this as a type load exception */
170 MonoAssemblyName aname;
179 }
182 }
187 {
191 }
193 /* Copy everything mono_metadata_free_array free. */
194 MonoArrayType *
196 {
209 }
211 }
213 /* Copy everything mono_metadata_free_method_signature free. */
214 MonoMethodSignature*
216 {
226 }
228 static void
230 {
240 }
244 {
247 }
249 static void
251 MonoTypeNameFormat format)
252 {
258 MonoTypeNameFormat nested_format;
277 }
279 MonoTypeNameFormat nested_format;
293 }
295 MonoTypeNameFormat nested_format;
309 }
313 g_string_append_printf (str, "%s%d", type->type == MONO_TYPE_VAR ? "!" : "!!", type->data.generic_param->num);
314 else
327 else
332 }
345 MonoTypeNameFormat nested_format;
353 else
367 }
370 else
379 else
384 g_string_append (str, mono_generic_container_get_param_info (klass->generic_container, i)->name);
385 }
388 else
390 }
398 }
399 }
401 /**
402 * mono_type_get_name_full:
403 * @type: a type
404 * @format: the format for the return string.
405 *
406 *
407 * Returns: the string representation in a number of formats:
408 *
409 * if format is MONO_TYPE_NAME_FORMAT_REFLECTION, the return string is
410 * returned in the formatrequired by System.Reflection, this is the
411 * inverse of mono_reflection_parse_type ().
412 *
413 * if format is MONO_TYPE_NAME_FORMAT_IL, it returns a syntax that can
414 * be used by the IL assembler.
415 *
416 * if format is MONO_TYPE_NAME_FORMAT_FULL_NAME
417 *
418 * if format is MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED
419 */
422 {
430 }
432 /**
433 * mono_type_get_full_name:
434 * @class: a class
435 *
436 * Returns: the string representation for type as required by System.Reflection.
437 * The inverse of mono_reflection_parse_type ().
438 */
441 {
443 }
445 /**
446 * mono_type_get_name:
447 * @type: a type
448 *
449 * Returns: the string representation for type as it would be represented in IL code.
450 */
453 {
455 }
457 /*
458 * mono_type_get_underlying_type:
459 * @type: a type
460 *
461 * Returns: the MonoType for the underlying integer type if @type
462 * is an enum and byref is false, otherwise the type itself.
463 */
464 MonoType*
466 {
469 if (type->type == MONO_TYPE_GENERICINST && type->data.generic_class->container_class->enumtype && !type->byref)
472 }
474 /*
475 * mono_class_is_open_constructed_type:
476 * @type: a type
477 *
478 * Returns TRUE if type represents a generics open constructed type
479 * (not all the type parameters required for the instantiation have
480 * been provided).
481 */
482 gboolean
484 {
499 }
500 }
503 inflate_generic_type (MonoImage *image, MonoType *type, MonoGenericContext *context, MonoError *error)
504 {
516 mono_error_set_bad_image (error, image, "MVAR %d (%s) cannot be expanded in this context with %d instantiations",
519 }
521 /*
522 * Note that the VAR/MVAR cases are different from the rest. The other cases duplicate @type,
523 * while the VAR/MVAR duplicates a type from the context. So, we need to ensure that the
524 * ->byref and ->attrs from @type are propagated to the returned type.
525 */
530 }
539 mono_error_set_bad_image (error, image, "VAR %d (%s) cannot be expanded in this context with %d instantiations",
542 }
547 }
557 }
567 }
579 gclass = mono_metadata_lookup_generic_class (gclass->container_class, inst, gclass->is_dynamic);
587 }
599 /* We can't use context->class_inst directly, since it can have more elements */
612 }
615 }
617 }
619 MonoGenericContext *
621 {
623 }
625 MonoGenericContext *
627 {
629 }
631 /*
632 * mono_class_get_generic_container:
633 *
634 * Return the generic container of KLASS which should be a generic type definition.
635 */
636 MonoGenericContainer*
638 {
642 }
644 /*
645 * mono_class_get_generic_class:
646 *
647 * Return the MonoGenericClass of KLASS, which should be a generic instance.
648 */
649 MonoGenericClass*
651 {
655 }
657 /*
658 * mono_class_inflate_generic_type_with_mempool:
659 * @mempool: a mempool
660 * @type: a type
661 * @context: a generics context
662 * @error: error context
663 *
664 * The same as mono_class_inflate_generic_type, but allocates the MonoType
665 * from mempool if it is non-NULL. If it is NULL, the MonoType is
666 * allocated on the heap and is owned by the caller.
667 * The returned type can potentially be the same as TYPE, so it should not be
668 * modified by the caller, and it should be freed using mono_metadata_free_type ().
669 */
670 MonoType*
671 mono_class_inflate_generic_type_with_mempool (MonoImage *image, MonoType *type, MonoGenericContext *context, MonoError *error)
672 {
688 }
689 }
693 }
695 /*
696 * mono_class_inflate_generic_type:
697 * @type: a type
698 * @context: a generics context
699 *
700 * If @type is a generic type and @context is not NULL, instantiate it using the
701 * generics context @context.
702 *
703 * Returns: the instantiated type or a copy of @type. The returned MonoType is allocated
704 * on the heap and is owned by the caller. Returns NULL on error.
705 *
706 * @deprecated Please use mono_class_inflate_generic_type_checked instead
707 */
708 MonoType*
710 {
711 MonoError error;
718 }
720 }
722 /*
723 * mono_class_inflate_generic_type:
724 * @type: a type
725 * @context: a generics context
726 * @error: error context to use
727 *
728 * If @type is a generic type and @context is not NULL, instantiate it using the
729 * generics context @context.
730 *
731 * Returns: the instantiated type or a copy of @type. The returned MonoType is allocated
732 * on the heap and is owned by the caller.
733 */
734 MonoType*
735 mono_class_inflate_generic_type_checked (MonoType *type, MonoGenericContext *context, MonoError *error)
736 {
738 }
740 /*
741 * mono_class_inflate_generic_type_no_copy:
742 *
743 * Same as inflate_generic_type_with_mempool, but return TYPE if no inflation
744 * was done.
745 */
747 mono_class_inflate_generic_type_no_copy (MonoImage *image, MonoType *type, MonoGenericContext *context)
748 {
749 MonoError error;
755 }
762 }
765 mono_class_inflate_generic_class_checked (MonoClass *gklass, MonoGenericContext *context, MonoError *error)
766 {
778 }
779 /*
780 * mono_class_inflate_generic_class:
781 *
782 * Inflate the class GKLASS with CONTEXT.
783 */
784 MonoClass*
786 {
787 MonoError error;
794 }
798 static MonoGenericContext
799 inflate_generic_context (MonoGenericContext *context, MonoGenericContext *inflate_with, MonoError *error)
800 {
811 }
817 }
821 fail:
823 }
825 /*
826 * mono_class_inflate_generic_method:
827 * @method: a generic method
828 * @context: a generics context
829 *
830 * Instantiate the generic method @method using the generics context @context.
831 *
832 * Returns: the new instantiated method
833 */
834 MonoMethod *
836 {
838 }
840 /**
841 * mono_class_inflate_generic_method_full:
842 *
843 * Instantiate method @method with the generic context @context.
844 * BEWARE: All non-trivial fields are invalid, including klass, signature, and header.
845 * Use mono_method_signature () and mono_method_get_header () to get the correct values.
846 */
847 MonoMethod*
848 mono_class_inflate_generic_method_full (MonoMethod *method, MonoClass *klass_hint, MonoGenericContext *context)
849 {
850 MonoError error;
851 MonoMethod *res = mono_class_inflate_generic_method_full_checked (method, klass_hint, context, &error);
853 /*FIXME do proper error handling - on this case, kill this function. */
857 }
859 /**
860 * mono_class_inflate_generic_method_full_checked:
861 * Same as mono_class_inflate_generic_method_full but return failure using @error.
862 */
863 MonoMethod*
864 mono_class_inflate_generic_method_full_checked (MonoMethod *method, MonoClass *klass_hint, MonoGenericContext *context, MonoError *error)
865 {
869 MonoGenericContext tmp_context;
874 /* The `method' has already been instantiated before => we need to peel out the instantiation and create a new context */
888 }
893 /*
894 * The reason for this hack is to fix the behavior of inflating generic methods that come from a MethodBuilder.
895 * What happens is that instantiating a generic MethodBuilder with its own arguments should create a diferent object.
896 * This is opposite to the way non-SRE MethodInfos behave.
897 *
898 * This happens, for example, when we want to emit a recursive generic method. Given the following C# code:
899 *
900 * void Example<T> () {
901 * Example<T> ();
902 * }
903 *
904 * In Example, the method token must be encoded as: "void Example<!!0>()"
905 *
906 * The reference to the first generic argument, "!!0", must be explicit otherwise it won't be inflated
907 * properly. To get that we need to inflate the MethodBuilder with its own arguments.
908 *
909 * On the other hand, inflating a non-SRE generic method with its own arguments should
910 * return itself. For example:
911 *
912 * MethodInfo m = ... //m is a generic method definition
913 * MethodInfo res = m.MakeGenericMethod (m.GetGenericArguments ());
914 * res == m
915 *
916 * To allow such scenarios we must allow inflation of MethodBuilder to happen in a diferent way than
917 * what happens with regular methods.
918 *
919 * There is one last touch to this madness, once a TypeBuilder is finished, IOW CreateType() is called,
920 * everything should behave like a regular type or method.
921 *
922 */
924 method->klass->image->dynamic && !method->klass->wastypebuilder && /* that is a MethodBuilder from an unfinished TypeBuilder */
925 context->method_inst == mono_method_get_generic_container (method)->context.method_inst; /* and it's been instantiated with its own arguments. */
941 }
949 }
958 mono_error_set_bad_image (error, method->klass->image, "Could not resolve signature of method %s:%s", name, method->name);
961 }
967 }
977 /* Set the generic_container of the result to the generic_container of method */
983 }
984 }
1002 }
1008 fail:
1012 }
1014 /**
1015 * mono_get_inflated_method:
1016 *
1017 * Obsolete. We keep it around since it's mentioned in the public API.
1018 */
1019 MonoMethod*
1021 {
1023 }
1025 /*
1026 * mono_method_get_context_general:
1027 * @method: a method
1028 * @uninflated: handle uninflated methods?
1029 *
1030 * Returns the generic context of a method or NULL if it doesn't have
1031 * one. For an inflated method that's the context stored in the
1032 * method. Otherwise it's in the method's generic container or in the
1033 * generic container of the method's class.
1034 */
1035 MonoGenericContext*
1037 {
1041 }
1049 }
1051 /*
1052 * mono_method_get_context:
1053 * @method: a method
1054 *
1055 * Returns the generic context for method if it's inflated, otherwise
1056 * NULL.
1057 */
1058 MonoGenericContext*
1060 {
1062 }
1064 /*
1065 * mono_method_get_generic_container:
1066 *
1067 * Returns the generic container of METHOD, which should be a generic method definition.
1068 * Returns NULL if METHOD is not a generic method definition.
1069 * LOCKING: Acquires the loader lock.
1070 */
1071 MonoGenericContainer*
1073 {
1079 container = mono_image_property_lookup (method->klass->image, method, MONO_METHOD_PROP_GENERIC_CONTAINER);
1083 }
1085 /*
1086 * mono_method_set_generic_container:
1087 *
1088 * Sets the generic container of METHOD to CONTAINER.
1089 * LOCKING: Acquires the loader lock.
1090 */
1091 void
1093 {
1096 mono_image_property_insert (method->klass->image, method, MONO_METHOD_PROP_GENERIC_CONTAINER, container);
1097 }
1099 /**
1100 * mono_class_find_enum_basetype:
1101 * @class: The enum class
1102 *
1103 * Determine the basetype of an enum by iterating through its fields. We do this
1104 * in a separate function since it is cheaper than calling mono_class_setup_fields.
1105 */
1108 {
1123 }
1125 /*
1126 * Fetch all the field information.
1127 */
1134 /* class->field.first and idx points into the fieldptr table */
1145 /* FIELD signature == 0x06 */
1149 ftype = mono_metadata_parse_type_full (m, container, MONO_PARSE_FIELD, cols [MONO_FIELD_FLAGS], sig + 1, &sig);
1153 //FIXME do we leak here?
1156 }
1159 }
1162 }
1164 /*
1165 * Checks for MonoClass::exception_type without resolving all MonoType's into MonoClass'es
1166 */
1167 static gboolean
1169 {
1179 }
1181 }
1183 /**
1184 * mono_class_setup_fields:
1185 * @class: The class to initialize
1186 *
1187 * Initializes the class->fields.
1188 * LOCKING: Assumes the loader lock is held.
1189 */
1190 static void
1192 {
1199 gboolean explicit_size;
1207 if (class->generic_class && class->generic_class->container_class->image->dynamic && !class->generic_class->container_class->wastypebuilder) {
1208 /*
1209 * This happens when a generic instance of an unfinished generic typebuilder
1210 * is used as an element type for creating an array type. We can't initialize
1211 * the fields of this class using the fields of gklass, since gklass is not
1212 * finished yet, fields could be added to it later.
1213 */
1215 }
1222 }
1227 }
1234 /* For generic instances, class->parent might not have been initialized */
1241 }
1242 }
1245 /* we use |= since it may have been set already */
1251 }
1253 /* We can't really enable 16 bytes alignment until the GC supports it.
1254 The whole layout/instance size code must be reviewed because we do alignment calculation in terms of the
1255 boxed instance, which leads to unexplainable holes at the beginning of an object embedding a simd type.
1256 Bug #506144 is an example of this issue.
1258 if (class->simd_type)
1259 class->min_align = 16;
1260 */
1261 /* Get the real size */
1262 explicit_size = mono_metadata_packing_from_typedef (class->image, class->type_token, &packing_size, &real_size);
1268 }
1273 }
1277 }
1282 /* Prevent infinite loops if the class references itself */
1292 }
1294 /*
1295 * Fetch all the field information.
1296 */
1307 /*This memory must come from the image mempool as we don't have a chance to free it.*/
1308 field->type = mono_class_inflate_generic_type_no_copy (class->image, gfield->type, mono_class_get_context (class));
1317 /* class->field.first and idx points into the fieldptr table */
1319 /* The name is needed for fieldrefs */
1324 }
1327 /* FIELD signature == 0x06 */
1329 field->type = mono_metadata_parse_type_full (m, container, MONO_PARSE_FIELD, cols [MONO_FIELD_FLAGS], sig + 1, &sig);
1333 }
1337 guint32 offset;
1342 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Missing field layout info for %s", field->name));
1344 }
1346 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Invalid negative field offset %d for %s", field->offset, field->name));
1348 }
1349 }
1350 }
1352 /* Only do these checks if we still think this type is blittable */
1363 }
1364 }
1367 }
1368 }
1373 }
1384 }
1385 /* The def_value of fields is compute lazily during vtable creation */
1386 }
1396 }
1399 }
1405 /*valuetypes can't be neither bigger than 1Mb or empty. */
1406 if (class->valuetype && (class->instance_size <= 0 || class->instance_size > (0x100000 + sizeof (MonoObject))))
1408 }
1410 /**
1411 * mono_class_setup_fields_locking:
1412 * @class: The class to initialize
1413 *
1414 * Initializes the class->fields array of fields.
1415 * Aquires the loader lock.
1416 */
1417 static void
1419 {
1423 }
1425 /*
1426 * mono_class_has_references:
1427 *
1428 * Returns whenever @klass->has_references is set, initializing it if needed.
1429 * Aquires the loader lock.
1430 */
1431 static gboolean
1433 {
1435 /* Be conservative */
1441 }
1442 }
1444 /* useful until we keep track of gc-references in corlib etc. */
1445 #ifdef HAVE_SGEN_GC
1446 #define IS_GC_REFERENCE(t) FALSE
1447 #else
1448 #define IS_GC_REFERENCE(t) ((t)->type == MONO_TYPE_U && class->image == mono_defaults.corlib)
1449 #endif
1451 /*
1452 * mono_type_get_basic_type_from_generic:
1453 * @type: a type
1454 *
1455 * Returns a closed type corresponding to the possibly open type
1456 * passed to it.
1457 */
1458 MonoType*
1460 {
1461 /* When we do generic sharing we let type variables stand for reference types. */
1465 }
1467 /*
1468 * mono_class_layout_fields:
1469 * @class: a class
1470 *
1471 * Compute the placement of fields inside an object or struct, according to
1472 * the layout rules and set the following fields in @class:
1473 * - has_references (if the class contains instance references firled or structs that contain references)
1474 * - has_static_refs (same, but for static fields)
1475 * - instance_size (size of the object in memory)
1476 * - class_size (size needed for the static fields)
1477 * - size_inited (flag set when the instance_size is set)
1478 *
1479 * LOCKING: this is supposed to be called with the loader lock held.
1480 */
1481 void
1483 {
1491 /*
1492 * When we do generic sharing we need to have layout
1493 * information for open generic classes (either with a generic
1494 * context containing type variables or with a generic
1495 * container), so we don't return in that case anymore.
1496 */
1498 /*
1499 * Enable GC aware auto layout: in this mode, reference
1500 * fields are grouped together inside objects, increasing collector
1501 * performance.
1502 * Requires that all classes whose layout is known to native code be annotated
1503 * with [StructLayout (LayoutKind.Sequential)]
1504 * Value types have gc_aware_layout disabled by default, as per
1505 * what the default is for other runtimes.
1506 */
1507 /* corlib is missing [StructLayout] directives in many places */
1512 /* from System.dll, used in metadata/process.h */
1515 }
1517 /* Compute klass->has_references */
1518 /*
1519 * Process non-static fields first, since static fields might recursively
1520 * refer to the class itself.
1521 */
1530 if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype)))))
1532 }
1533 }
1543 if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype)))))
1545 }
1546 }
1555 if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype))))) {
1558 else
1560 }
1561 }
1563 /*
1564 * Compute field layout and total size (not considering static fields)
1565 */
1573 else
1581 else
1586 gint32 align;
1587 guint32 size;
1600 if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype))))) {
1606 }
1607 }
1611 /* This field is a hack inserted by MCS to empty structures */
1613 }
1617 /* FIXME (LAMESPEC): should we also change the min alignment according to pack? */
1619 /* if the field has managed references, we need to force-align it
1620 * see bug #77788
1621 */
1622 if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype)))))
1630 }
1637 }
1638 }
1643 gint32 align;
1644 guint32 size;
1649 /*
1650 * There must be info about all the fields in a type if it
1651 * uses explicit layout.
1652 */
1662 /*
1663 * When we get here, field->offset is already set by the
1664 * loader (for either runtime fields or fields loaded from metadata).
1665 * The offset is from the start of the object: this works for both
1666 * classes and valuetypes.
1667 */
1671 if (MONO_TYPE_IS_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype))))) {
1674 }
1675 }
1677 /*
1678 * Calc max size.
1679 */
1681 }
1684 }
1687 /*
1688 * For small structs, set min_align to at least the struct size to improve
1689 * performance, and since the JIT memset/memcpy code assumes this and generates
1690 * unaligned accesses otherwise. See #78990 for a testcase.
1691 */
1694 }
1698 /*
1699 * Compute static field layout and size
1700 */
1702 gint32 align;
1703 guint32 size;
1707 if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC) || field->type->attrs & FIELD_ATTRIBUTE_LITERAL)
1715 }
1722 }
1723 }
1727 {
1737 /* .ctor */
1742 }
1744 }
1746 /*
1747 * mono_class_setup_methods:
1748 * @class: a class
1749 *
1750 * Initializes the 'methods' array in the klass.
1751 * Calling this method should be avoided if possible since it allocates a lot
1752 * of long-living MonoMethod structures.
1753 * Methods belonging to an interface are assigned a sequential slot starting
1754 * from 0.
1755 *
1756 * On failure this function sets class->exception_type
1757 */
1758 void
1760 {
1772 }
1775 MonoError error;
1782 /*FIXME make exception_data less opaque so it's possible to dup it here*/
1783 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Generic type definition failed to load"));
1786 }
1788 /* The + 1 makes this always non-NULL to pass the check in mono_class_setup_methods () */
1797 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)));
1803 }
1804 }
1806 MonoError error;
1821 }
1844 }
1845 /* element Get (idx11, [idx2, ...]) */
1854 /* element& Address (idx11, [idx2, ...]) */
1863 /* void Set (idx11, [idx2, ...], element) */
1875 setup_generic_array_ifaces (class, class->interfaces [i], methods, first_generic + i * count_generic);
1879 int idx = mono_metadata_translate_token_index (class->image, MONO_TABLE_METHOD, class->method.first + i + 1);
1881 }
1882 }
1886 /*Only assign slots to virtual methods as interfaces are allowed to have static methods.*/
1890 }
1891 }
1893 /* Needed because of the double-checking locking pattern */
1902 }
1904 /*
1905 * mono_class_get_method_by_index:
1906 *
1907 * Returns class->methods [index], initializing class->methods if neccesary.
1908 *
1909 * LOCKING: Acquires the loader lock.
1910 */
1911 MonoMethod*
1913 {
1914 /* Avoid calling setup_methods () if possible */
1921 /*
1922 * If setup_methods () is called later for this class, no duplicates are created,
1923 * since inflate_generic_method guarantees that only one instance of a method
1924 * is created for each context.
1925 */
1926 /*
1927 mono_class_setup_methods (class);
1928 g_assert (m == class->methods [index]);
1929 */
1936 }
1937 }
1939 /*
1940 * mono_class_get_inflated_method:
1941 *
1942 * Given an inflated class CLASS and a method METHOD which should be a method of
1943 * CLASS's generic definition, return the inflated method corresponding to METHOD.
1944 */
1945 MonoMethod*
1947 {
1960 else
1961 return mono_class_inflate_generic_method_full (gklass->methods [i], class, mono_class_get_context (class));
1962 }
1963 }
1966 }
1968 /*
1969 * mono_class_get_vtable_entry:
1970 *
1971 * Returns class->vtable [offset], computing it if neccesary.
1972 * LOCKING: Acquires the loader lock.
1973 */
1974 MonoMethod*
1976 {
1980 /*
1981 * szarrays do not overwrite any methods of Array, so we can avoid
1982 * initializing their vtables in some cases.
1983 */
1987 }
1998 }
2001 }
2003 /*
2004 * mono_class_get_vtable_size:
2005 *
2006 * Return the vtable size for KLASS.
2007 */
2008 int
2010 {
2014 }
2016 /*This method can fail the class.*/
2017 static void
2019 {
2024 guint32 last;
2034 }
2044 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Generic type definition failed to load"));
2047 }
2066 }
2068 int first = mono_metadata_properties_from_typedef (class->image, mono_metadata_token_index (class->type_token) - 1, &last);
2076 }
2077 }
2083 mono_metadata_decode_table_row (class->image, MONO_TABLE_PROPERTY, i, cols, MONO_PROPERTY_SIZE);
2086 properties [i - first].name = mono_metadata_string_heap (class->image, cols [MONO_PROPERTY_NAME]);
2095 /* It seems like the MONO_METHOD_SEMA_METHOD column needs no remapping */
2096 method = mono_get_method (class->image, MONO_TOKEN_METHOD_DEF | cols [MONO_METHOD_SEMA_METHOD], class);
2097 else
2109 }
2110 }
2111 }
2112 }
2113 /*Flush any pending writes as we do double checked locking on class->properties */
2116 /* Leave this assignment as the last op in the function */
2120 }
2124 {
2129 ;
2137 }
2139 /*This method can fail the class.*/
2140 static void
2142 {
2147 guint32 last;
2158 }
2168 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Generic type definition failed to load"));
2171 }
2185 event->add = gevent->add ? mono_class_inflate_generic_method_full (gevent->add, class, context) : NULL;
2186 event->remove = gevent->remove ? mono_class_inflate_generic_method_full (gevent->remove, class, context) : NULL;
2187 event->raise = gevent->raise ? mono_class_inflate_generic_method_full (gevent->raise, class, context) : NULL;
2188 #ifndef MONO_SMALL_CONFIG
2190 #endif
2192 }
2196 }
2198 first = mono_metadata_events_from_typedef (class->image, mono_metadata_token_index (class->type_token) - 1, &last);
2204 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Generic type definition failed to load"));
2207 }
2208 }
2227 /* It seems like the MONO_METHOD_SEMA_METHOD column needs no remapping */
2228 method = mono_get_method (class->image, MONO_TOKEN_METHOD_DEF | cols [MONO_METHOD_SEMA_METHOD], class);
2229 else
2243 #ifndef MONO_SMALL_CONFIG
2250 n++;
2252 }
2254 /* NULL terminated */
2256 #endif
2258 }
2261 }
2262 }
2263 }
2264 /*Flush any pending writes as we do double checked locking on class->properties */
2267 /* Leave this assignment as the last op in the function */
2271 }
2273 /*
2274 * Global pool of interface IDs, represented as a bitset.
2275 * LOCKING: this is supposed to be accessed with the loader lock held.
2276 */
2279 /*
2280 * mono_unload_interface_ids:
2281 * @bitset: bit set of interface IDs
2282 *
2283 * When an image is unloaded, the interface IDs associated with
2284 * the image are put back in the global pool of IDs so the numbers
2285 * can be reused.
2286 */
2287 void
2289 {
2293 }
2295 /*
2296 * mono_get_unique_iid:
2297 * @class: interface
2298 *
2299 * Assign a unique integer ID to the interface represented by @class.
2300 * The ID will positive and as small as possible.
2301 * LOCKING: this is supposed to be called with the loader lock held.
2302 * Returns: the new ID.
2303 */
2304 static guint
2306 {
2313 }
2322 }
2324 /* set the bit also in the per-image set */
2330 }
2333 }
2336 #ifndef MONO_SMALL_CONFIG
2345 }
2346 printf ("Interface: assigned id %d to %s|%s|%d\n", iid, class->image->name, type_name, generic_id);
2348 }
2349 #endif
2353 }
2355 static void
2357 {
2376 }
2377 }
2379 GPtrArray*
2381 {
2389 }
2391 }
2393 static int
2399 }
2401 /*FIXME verify all callers if they should switch to mono_class_interface_offset_with_variance*/
2402 int
2405 itf,
2409 compare_interface_ids);
2414 }
2415 }
2417 /*
2418 * mono_class_interface_offset_with_variance:
2419 *
2420 * Return the interface offset of @itf in @klass. Sets @non_exact_match to TRUE if the match required variance check
2421 * If @itf is an interface with generic variant arguments, try to find the compatible one.
2422 *
2423 * Note that this function is responsible for resolving ambiguities. Right now we use whatever ordering interfaces_packed gives us.
2424 *
2425 * FIXME figure out MS disambiguation rules and fix this function.
2426 */
2427 int
2428 mono_class_interface_offset_with_variance (MonoClass *klass, MonoClass *itf, gboolean *non_exact_match) {
2441 }
2442 }
2445 }
2447 static void
2449 MonoError error;
2454 printf ("Packed interface table for class %s has size %d\n", klass->name, klass->interface_offsets_count);
2466 else
2470 #ifdef COMPRESSED_INTERFACE_BITMAP
2471 {
2478 }
2479 }
2480 #else
2481 for (i = 0; i < ((((klass->max_interface_id + 1) >> 3)) + (((klass->max_interface_id + 1) & 7)? 1 :0)); i++)
2483 #endif
2501 }
2503 }
2504 ancestor_level ++;
2506 }
2507 }
2511 {
2516 }
2520 {
2522 }
2524 static void
2526 {
2546 }
2548 /* this won't be needed once bug #325495 is completely fixed
2549 * though we'll need something similar to know which interfaces to allow
2550 * in arrays when they'll be lazyly created
2551 *
2552 * FIXME: System.Array/InternalEnumerator don't need all this interface fabrication machinery.
2553 * MS returns diferrent types based on which instance is called. For example:
2554 * object obj = new byte[10][];
2555 * Type a = ((IEnumerable<byte[]>)obj).GetEnumerator ().GetType ();
2556 * Type b = ((IEnumerable<IList<byte>>)obj).GetEnumerator ().GetType ();
2557 * a != b ==> true
2558 *
2559 * Fixing this should kill quite some code, save some bits and improve compatibility.
2560 */
2563 {
2572 gboolean internal_enumerator;
2573 gboolean eclass_is_valuetype;
2578 }
2583 if (class->generic_class && class->nested_in == mono_defaults.array_class && strcmp (class->name, "InternalEnumerator`1") == 0) {
2584 /*
2585 * For a Enumerator<T[]> we need to get the list of interfaces for T.
2586 */
2595 }
2596 }
2598 /*
2599 * with this non-lazy impl we can't implement all the interfaces so we do just the minimal stuff
2600 * for deep levels of arrays of arrays (string[][] has all the interfaces, string[][][] doesn't)
2601 */
2611 }
2615 /*
2616 * Arrays in 2.0 need to implement a number of generic interfaces
2617 * (IList`1, ICollection`1, IEnumerable`1 for a number of types depending
2618 * on the element class). We collect the types needed to build the
2619 * instantiations in interfaces at intervals of 3, because 3 are
2620 * the generic interfaces needed to implement.
2621 */
2625 /* IList, ICollection, IEnumerable */
2631 }
2643 idepth--;
2645 // FIXME: This doesn't seem to work/required for generic params
2646 if (!(eclass->this_arg.type == MONO_TYPE_VAR || eclass->this_arg.type == MONO_TYPE_MVAR || (eclass->image->dynamic && !eclass->wastypebuilder)))
2650 /* we add object for interfaces and the supertypes for the other
2651 * types. The last of the supertypes is the element class itself which we
2652 * already created the explicit interfaces for (so we include it for IEnumerator
2653 * and exclude it for arrays).
2654 */
2656 interface_count++;
2657 else
2663 }
2664 /* IList, ICollection, IEnumerable */
2668 real_count += (MONO_CLASS_IS_INTERFACE (eclass) ? 1 : idepth) + eclass->interface_offsets_count;
2671 }
2682 }
2683 }
2688 }
2693 }
2694 }
2698 }
2699 }
2701 /* instantiate the generic interfaces */
2708 }
2711 /* instantiate IEnumerator<iface> */
2714 }
2718 interfaces [j] = inflate_class_one_arg (generic_ienumerator_class, mono_defaults.object_class);
2719 j ++;
2723 j ++;
2724 }
2725 }
2727 interfaces [j] = inflate_class_one_arg (generic_ienumerator_class, eclass->interfaces_packed [i]);
2728 j ++;
2729 }
2731 interfaces [j++] = inflate_class_one_arg (generic_ienumerator_class, array_class_get_if_rank (valuetype_types [0], original_rank));
2732 }
2734 interfaces [j] = inflate_class_one_arg (generic_ienumerator_class, array_class_get_if_rank (valuetype_types [1], original_rank));
2735 }
2736 #if 0
2737 {
2743 }
2745 }
2746 #endif
2749 }
2751 static int
2753 {
2758 }
2760 }
2762 /*
2763 * Return the number of virtual methods.
2764 * Even for interfaces we can't simply return the number of methods as all CLR types are allowed to have static methods.
2765 * Return -1 on failure.
2766 * FIXME It would be nice if this information could be cached somewhere.
2767 */
2768 static int
2770 {
2772 guint32 flags;
2773 class = mono_class_get_generic_type_definition (class); /*We can find this information by looking at the GTD*/
2784 }
2787 flags = mono_metadata_decode_table_row_col (class->image, MONO_TABLE_METHOD, class->method.first + i, MONO_METHOD_FLAGS);
2791 }
2792 }
2794 }
2796 static int
2798 {
2814 }
2815 }
2816 }
2818 static int
2819 find_interface_offset (int num_ifaces, MonoClass **interfaces_full, int *interface_offsets_full, MonoClass *ic)
2820 {
2825 }
2827 static mono_bool
2828 set_interface_and_offset (int num_ifaces, MonoClass **interfaces_full, int *interface_offsets_full, MonoClass *ic, int offset, mono_bool force_set)
2829 {
2836 }
2845 memmove (interface_offsets_full + i + 1, interface_offsets_full + i, sizeof (int) * (end - i));
2846 }
2850 }
2852 }
2854 #ifdef COMPRESSED_INTERFACE_BITMAP
2856 /*
2857 * Compressed interface bitmap design.
2858 *
2859 * Interface bitmaps take a large amount of memory, because their size is
2860 * linear with the maximum interface id assigned in the process (each interface
2861 * is assigned a unique id as it is loaded). The number of interface classes
2862 * is high because of the many implicit interfaces implemented by arrays (we'll
2863 * need to lazy-load them in the future).
2864 * Most classes implement a very small number of interfaces, so the bitmap is
2865 * sparse. This bitmap needs to be checked by interface casts, so access to the
2866 * needed bit must be fast and doable with few jit instructions.
2867 *
2868 * The current compression format is as follows:
2869 * *) it is a sequence of one or more two-byte elements
2870 * *) the first byte in the element is the count of empty bitmap bytes
2871 * at the current bitmap position
2872 * *) the second byte in the element is an actual bitmap byte at the current
2873 * bitmap position
2874 *
2875 * As an example, the following compressed bitmap bytes:
2876 * 0x07 0x01 0x00 0x7
2877 * correspond to the following bitmap:
2878 * 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x01 0x07
2879 *
2880 * Each two-byte element can represent up to 2048 bitmap bits, but as few as a single
2881 * bitmap byte for non-sparse sequences. In practice the interface bitmaps created
2882 * during a gmcs bootstrap are reduced to less tha 5% of the original size.
2883 */
2885 /**
2886 * mono_compress_bitmap:
2887 * @dest: destination buffer
2888 * @bitmap: bitmap buffer
2889 * @size: size of @bitmap in bytes
2890 *
2891 * This is a mono internal function.
2892 * The @bitmap data is compressed into a format that is small but
2893 * still searchable in few instructions by the JIT and runtime.
2894 * The compressed data is stored in the buffer pointed to by the
2895 * @dest array. Passing a #NULL value for @dest allows to just compute
2896 * the size of the buffer.
2897 * This compression algorithm assumes the bits set in the bitmap are
2898 * few and far between, like in interface bitmaps.
2899 * Returns: the size of the compressed bitmap in bytes.
2900 */
2901 int
2903 {
2912 }
2915 bitmap++;
2917 }
2918 bitmap++;
2919 numz++;
2920 }
2926 }
2927 }
2929 }
2931 /**
2932 * mono_class_interface_match:
2933 * @bitmap: a compressed bitmap buffer
2934 * @id: the index to check in the bitmap
2935 *
2936 * This is a mono internal function.
2937 * Checks if a bit is set in a compressed interface bitmap. @id must
2938 * be already checked for being smaller than the maximum id encoded in the
2939 * bitmap.
2940 *
2941 * Returns: a non-zero value if bit @id is set in the bitmap @bitmap,
2942 * #FALSE otherwise.
2943 */
2944 int
2946 {
2953 }
2956 }
2957 }
2958 #endif
2960 /*
2961 * LOCKING: this is supposed to be called with the loader lock held.
2962 * Return -1 on failure and set exception_type
2963 */
2964 static int
2966 {
2967 MonoError error;
2980 /*
2981 * get the implicit generic interfaces for either the arrays or for System.Array/InternalEnumerator<T>
2982 * implicit interfaces have the property that they are assigned the same slot in the
2983 * vtables for compatible interfaces
2984 */
2985 array_interfaces = get_implicit_generic_array_interfaces (class, &num_array_interfaces, &is_enumerator);
2987 /* compute maximum number of slots and maximum interface id */
3002 }
3006 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Error getting the interfaces of %s due to %s", name, mono_error_get_message (&error)));
3011 }
3018 }
3020 }
3021 }
3028 }
3031 num_ifaces++;
3034 }
3036 /* compute vtable offset for interfaces */
3042 }
3044 /* skip the current class */
3054 /*Force the sharing of interface offsets between parent and subtypes.*/
3058 }
3059 }
3060 }
3068 if (set_interface_and_offset (num_ifaces, interfaces_full, interface_offsets_full, ic, cur_slot, FALSE))
3073 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Error calculating interface offset of %s", name));
3077 }
3079 }
3080 }
3083 set_interface_and_offset (num_ifaces, interfaces_full, interface_offsets_full, class, cur_slot, TRUE);
3088 int ienumerator_offset = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, class->interfaces [ienumerator_idx]);
3093 set_interface_and_offset (num_ifaces, interfaces_full, interface_offsets_full, ic, ienumerator_offset, TRUE);
3094 else
3096 /*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);*/
3097 }
3104 ilist_offset = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, class->interfaces [ilist_iface_idx]);
3105 icollection_offset = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, ilist_class->interfaces [icollection_iface_idx]);
3106 ienumerable_offset = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, ilist_class->interfaces [ienumerable_iface_idx]);
3117 else
3119 set_interface_and_offset (num_ifaces, interfaces_full, interface_offsets_full, ic, offset, TRUE);
3120 /*g_print ("type %s has %s offset at %d (%s)\n", class->name, ic->name, offset, class->interfaces [0]->name);*/
3121 }
3122 }
3123 }
3127 interface_offsets_count ++;
3128 }
3129 }
3131 /*
3132 * We might get called twice: once from mono_class_init () then once from
3133 * mono_class_setup_vtable ().
3134 */
3141 class->interfaces_packed = mono_image_alloc (class->image, sizeof (MonoClass*) * interface_offsets_count);
3142 class->interface_offsets_packed = mono_image_alloc (class->image, sizeof (guint16) * interface_offsets_count);
3144 #ifdef COMPRESSED_INTERFACE_BITMAP
3146 #else
3148 #endif
3154 /*if (num_array_interfaces)
3155 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]);*/
3156 }
3157 #ifdef COMPRESSED_INTERFACE_BITMAP
3162 #else
3164 #endif
3165 }
3167 end:
3175 }
3178 //printf ("JUST DONE: ");
3179 //print_implemented_interfaces (class);
3182 }
3184 /*
3185 * Setup interface offsets for interfaces.
3186 * Initializes:
3187 * - class->max_interface_id
3188 * - class->interface_offsets_count
3189 * - class->interfaces_packed
3190 * - class->interface_offsets_packed
3191 * - class->interface_bitmap
3192 *
3193 * This function can fail @class.
3194 */
3195 void
3197 {
3203 }
3205 /*
3206 * mono_class_setup_vtable:
3207 *
3208 * Creates the generic vtable of CLASS.
3209 * Initializes the following fields in MonoClass:
3210 * - vtable
3211 * - vtable_size
3212 * Plus all the fields initialized by setup_interface_offsets ().
3213 * If there is an error during vtable construction, class->exception_type is set.
3214 *
3215 * LOCKING: Acquires the loader lock.
3216 */
3217 void
3219 {
3222 guint32 type_token;
3231 /* The debugger currently depends on this */
3235 /* This sets method->slot for all methods if this is an interface */
3238 }
3248 }
3258 }
3274 }
3275 }
3279 }
3282 }
3284 /* The following call fails if there are missing methods in the type */
3286 }
3296 }
3298 #define DEBUG_INTERFACE_VTABLE_CODE 0
3299 #define TRACE_INTERFACE_VTABLE_CODE 0
3300 #define VERIFY_INTERFACE_VTABLE_CODE 0
3301 #define VTABLE_SELECTOR (1)
3303 #if (TRACE_INTERFACE_VTABLE_CODE|DEBUG_INTERFACE_VTABLE_CODE)
3304 #define DEBUG_INTERFACE_VTABLE(stmt) do {\
3305 if (!(VTABLE_SELECTOR)) break; \
3306 stmt;\
3307 } while (0)
3308 #else
3309 #define DEBUG_INTERFACE_VTABLE(stmt)
3310 #endif
3312 #if TRACE_INTERFACE_VTABLE_CODE
3313 #define TRACE_INTERFACE_VTABLE(stmt) do {\
3314 if (!(VTABLE_SELECTOR)) break; \
3315 stmt;\
3316 } while (0)
3317 #else
3318 #define TRACE_INTERFACE_VTABLE(stmt)
3319 #endif
3321 #if VERIFY_INTERFACE_VTABLE_CODE
3322 #define VERIFY_INTERFACE_VTABLE(stmt) do {\
3323 if (!(VTABLE_SELECTOR)) break; \
3324 stmt;\
3325 } while (0)
3326 #else
3327 #define VERIFY_INTERFACE_VTABLE(stmt)
3328 #endif
3331 #if (TRACE_INTERFACE_VTABLE_CODE|DEBUG_INTERFACE_VTABLE_CODE)
3334 {
3344 }
3350 }
3354 }
3355 static void
3363 }
3365 #endif
3366 static gboolean
3367 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) {
3373 }
3379 }
3383 }
3386 }
3387 }
3391 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Could not resolve the signature of a virtual method"));
3393 }
3400 }
3402 /* CAS - SecurityAction.InheritanceDemand on interface */
3405 }
3420 }
3424 }
3425 if (! mono_metadata_signature_equal (mono_method_signature (cm), mono_method_signature (im))) {
3430 }
3434 }
3438 }
3439 if ((ic_name == NULL) || ((strcmp (ic_name, "IEnumerable`1") != 0) && (strcmp (ic_name, "ICollection`1") != 0) && (strcmp (ic_name, "IList`1") != 0))) {
3442 }
3448 }
3453 }
3454 subname ++;
3458 }
3463 }
3464 subname ++;
3468 }
3471 /* CAS - SecurityAction.InheritanceDemand on interface */
3474 }
3481 }
3482 }
3484 #if (TRACE_INTERFACE_VTABLE_CODE|DEBUG_INTERFACE_VTABLE_CODE)
3485 static void
3493 mono_class_get_namespace (method_class), mono_class_get_name (method_class), mono_method_get_name (method),
3494 mono_class_get_namespace (override_class), mono_class_get_name (override_class), mono_method_get_name (override));
3495 }
3496 static void
3504 }
3505 }
3506 static void
3507 print_vtable_full (MonoClass *class, MonoMethod** vtable, int size, int first_non_interface_slot, const char *message, gboolean print_interfaces) {
3517 }
3523 }
3531 }
3532 }
3535 }
3536 #endif
3538 #if VERIFY_INTERFACE_VTABLE_CODE
3539 static int
3541 {
3546 }
3548 }
3550 static void
3552 {
3576 printf ("\tInvalid method %s at index %d with vtable of length %d\n", full_name, slot, class->vtable_size);
3578 }
3581 char *other_name = class->vtable [slot] ? mono_method_full_name (class->vtable [slot], TRUE) : g_strdup ("[null value]");
3584 }
3587 }
3589 }
3590 #endif
3592 static void
3593 print_unimplemented_interface_method_info (MonoClass *class, MonoClass *ic, MonoMethod *im, int im_slot, MonoMethod **overrides, int onum) {
3601 }
3614 }
3621 }
3622 }
3624 static gboolean
3626 {
3633 if (mono_class_get_generic_type_definition (body->klass) != mono_class_get_generic_type_definition (class)) {
3634 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Method belongs to a different class than the declared one"));
3636 }
3640 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Method must not be static to override a base type"));
3641 else
3642 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Method must be virtual to override a base type"));
3644 }
3648 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Cannot override a static method in a base type"));
3649 else
3650 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Cannot override a non virtual method in a base type"));
3652 }
3655 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Method overrides a class or interface that extended or implemented by this type"));
3657 }
3658 }
3660 }
3661 /*
3662 * LOCKING: this is supposed to be called with the loader lock held.
3663 */
3664 void
3666 {
3667 MonoError error;
3675 gpointer class_iter;
3676 #if (DEBUG_INTERFACE_VTABLE_CODE|TRACE_INTERFACE_VTABLE_CODE)
3678 #endif
3690 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Could not resolve %s interfaces due to %s", name, mono_error_get_message (&error)));
3698 }
3701 }
3709 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Parent %s failed to load", name));
3712 }
3716 }
3723 /* printf ("METAINIT %s.%s\n", class->name_space, class->name); */
3732 /* Optimized version for generic instances */
3741 }
3747 tmp [i] = mono_class_inflate_generic_method_full (gklass->vtable [i], class, mono_class_get_context (class));
3749 }
3753 /* Have to set method->slot for abstract virtual methods */
3758 }
3761 }
3769 // Also inherit parent interface vtables, just as a starting point.
3770 // This is needed otherwise bug-77127.exe fails when the property methods
3771 // have different names in the iterface and the class, because for child
3772 // classes the ".override" information is not used anymore.
3776 /*FIXME this is now dead code as this condition will never hold true.
3777 Since interface offsets are inherited then the offset of an interface implemented
3778 by a parent will never be the out of it's vtable boundary.
3779 */
3785 TRACE_INTERFACE_VTABLE (printf (" +++ Inheriting interface %s.%s\n", parent_interface->name_space, parent_interface->name));
3788 TRACE_INTERFACE_VTABLE (printf (" --- Inheriting: [%03d][(%03d)+(%03d)] => [%03d][(%03d)+(%03d)]\n",
3791 }
3792 }
3794 }
3795 }
3797 TRACE_INTERFACE_VTABLE (print_vtable_full (class, vtable, cur_slot, first_non_interface_slot, "AFTER INHERITING PARENT VTABLE", TRUE));
3798 /* override interface methods */
3807 }
3819 }
3820 }
3822 TRACE_INTERFACE_VTABLE (print_vtable_full (class, vtable, cur_slot, first_non_interface_slot, "AFTER OVERRIDING INTERFACE METHODS", FALSE));
3824 /*
3825 * Create a list of virtual methods to avoid calling
3826 * mono_class_get_virtual_methods () which is slow because of the metadata
3827 * optimization.
3828 */
3829 {
3836 }
3839 }
3841 // Loop on all implemented interfaces...
3845 gboolean interface_is_explicitly_implemented_by_class;
3855 // Check if this interface is explicitly implemented (instead of just inherited)
3859 for (implemented_interfaces_index = 0; implemented_interfaces_index < class->interface_count; implemented_interfaces_index++) {
3863 }
3864 }
3867 }
3869 // Loop on all interface methods...
3873 MonoMethod *override_im = (override_map != NULL) ? g_hash_table_lookup (override_map, im) : NULL;
3878 // If there is an explicit implementation, just use it right away,
3879 // otherwise look for a matching method
3882 gpointer iter;
3885 // First look for a suitable method among the class methods
3889 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)));
3890 if (check_interface_method_override (class, im, cm, TRUE, interface_is_explicitly_implemented_by_class, (vtable [im_slot] == NULL), security_enabled)) {
3893 /* Why do we need this? */
3896 }
3897 }
3901 }
3903 // If the slot is still empty, look in all the inherited virtual methods...
3906 // Reverse order, so that last added methods are preferred
3910 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));
3911 if ((cm != NULL) && check_interface_method_override (class, im, cm, FALSE, FALSE, TRUE, security_enabled)) {
3914 /* Why do we need this? */
3917 }
3919 }
3923 }
3924 }
3927 }
3928 }
3929 }
3931 // If the class is not abstract, check that all its interface slots are full.
3932 // The check is done here and not directly at the end of the loop above because
3933 // it can happen (for injected generic array interfaces) that the same slot is
3934 // processed multiple times (those interfaces have overlapping slots), and it
3935 // will not always be the first pass the one that fills the slot.
3951 TRACE_INTERFACE_VTABLE (printf (" [class is not abstract, checking slot %d for interface '%s'.'%s', method %s, slot check is %d]\n",
3956 }
3957 }
3958 }
3959 }
3961 TRACE_INTERFACE_VTABLE (print_vtable_full (class, vtable, cur_slot, first_non_interface_slot, "AFTER SETTING UP INTERFACE METHODS", FALSE));
3965 /*
3966 * If the method is REUSE_SLOT, we must check in the
3967 * base class for a method to override.
3968 */
3972 gpointer k_iter;
3985 }
3990 /* CAS - SecurityAction.InheritanceDemand */
3993 }
4007 }
4008 }
4014 }
4017 }
4019 /*Non final newslot methods must be given a non-interface vtable slot*/
4020 if ((cm->flags & METHOD_ATTRIBUTE_NEW_SLOT) && !(cm->flags & METHOD_ATTRIBUTE_FINAL) && cm->slot >= 0)
4028 }
4030 /* override non interface methods */
4043 }
4044 }
4046 /*
4047 * If a method occupies more than one place in the vtable, and it is
4048 * overriden, then change the other occurances too.
4049 */
4056 }
4060 }
4065 /* Ensure that all vtable slots are filled with concrete instance methods */
4068 if (vtable [i] == NULL || (vtable [i]->flags & (METHOD_ATTRIBUTE_ABSTRACT | METHOD_ATTRIBUTE_STATIC))) {
4071 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));
4075 }
4076 }
4077 }
4086 /* Check that the vtable_size value computed in mono_class_init () is correct */
4090 }
4092 /* Try to share the vtable with our parent. */
4093 if (class->parent && (class->parent->vtable_size == class->vtable_size) && (memcmp (class->parent->vtable, vtable, sizeof (gpointer) * class->vtable_size) == 0)) {
4101 }
4103 DEBUG_INTERFACE_VTABLE (print_vtable_full (class, class->vtable, class->vtable_size, first_non_interface_slot, "FINALLY", FALSE));
4111 icount++;
4113 printf ("VTable %s (vtable entries = %d, interfaces = %d)\n", mono_type_full_name (&class->byval_arg),
4123 }
4124 }
4136 }
4144 }
4145 }
4146 }
4147 }
4152 fail:
4153 {
4155 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("VTable setup of type %s failed", name));
4161 }
4162 }
4164 /*
4165 * mono_method_get_vtable_slot:
4166 *
4167 * Returns method->slot, computing it if neccesary. Return -1 on failure.
4168 * LOCKING: Acquires the loader lock.
4169 *
4170 * FIXME Use proper MonoError machinery here.
4171 */
4172 int
4174 {
4180 }
4182 }
4184 /**
4185 * mono_method_get_vtable_index:
4186 * @method: a method
4187 *
4188 * Returns the index into the runtime vtable to access the method or,
4189 * in the case of a virtual generic method, the virtual generic method
4190 * thunk. Returns -1 on failure.
4191 *
4192 * FIXME Use proper MonoError machinery here.
4193 */
4194 int
4196 {
4201 }
4203 }
4210 static void
4212 {
4225 }
4232 }
4233 }
4243 static int
4245 {
4255 count_generic++;
4257 }
4258 }
4278 }
4284 i++;
4285 }
4286 /*g_print ("array generic methods: %d\n", count_generic);*/
4291 }
4293 static void
4295 {
4296 MonoGenericContext tmp_context;
4301 //g_print ("setting up array interface: %s\n", mono_type_get_name_full (&iface->byval_arg, 0));
4308 methods [pos++] = mono_marshal_get_generic_array_helper (class, iface, generic_array_method_info [i].name, inflated);
4309 }
4310 }
4314 {
4323 }
4325 static void
4327 {
4332 exception_data = concat_two_strings_with_zero (class->image, error->class_name, error->assembly_name);
4336 exception_data = concat_two_strings_with_zero (class->image, error->class_name, error->member_name);
4345 else
4353 }
4359 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.";
4360 else
4365 }
4373 }
4376 }
4378 /**
4379 * mono_class_init:
4380 * @class: the class to initialize
4381 *
4382 * Compute the instance_size, class_size and other infos that cannot be
4383 * computed at mono_class_get() time. Also compute vtable_size if possible.
4384 * Returns TRUE on success or FALSE if there was a problem in loading
4385 * the type (incorrect assemblies, missing assemblies, methods, etc).
4386 *
4387 * LOCKING: Acquires the loader lock.
4388 */
4389 gboolean
4391 {
4393 MonoCachedClassInfo cached_info;
4394 gboolean has_cached_info;
4398 /* Double-checking locking pattern */
4402 /*g_print ("Init class %s\n", class->name);*/
4404 /* We do everything inside the lock to prevent races */
4409 /* Somebody might have gotten in before us */
4411 }
4415 /* this indicates a cyclic dependency */
4417 }
4422 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, concat_two_strings_with_zero (class->image, class->name, class->image->assembly_name));
4424 }
4434 }
4435 }
4437 /* CAS - SecurityAction.InheritanceDemand */
4438 if (mono_is_security_manager_active () && class->parent && (class->parent->flags & TYPE_ATTRIBUTE_HAS_SECURITY)) {
4440 }
4456 // FIXME: Why is this needed ?
4460 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Generic Type Defintion failed to init"));
4462 }
4466 }
4473 if (class->generic_class || class->image->dynamic || !class->type_token || (has_cached_info && !cached_info.has_nested_classes))
4476 /*
4477 * Computes the size used by the fields, and their locations
4478 */
4488 }
4489 else
4494 }
4496 /* Initialize arrays */
4503 }
4504 }
4511 /*
4512 * Initialize the rest of the data without creating a generic vtable if possible.
4513 * If possible, also compute vtable_size, so mono_class_create_runtime_vtable () can
4514 * also avoid computing a generic vtable.
4515 */
4517 /* AOT case */
4525 /* SZARRAY case */
4531 }
4535 /* Generic instance case */
4544 }
4548 /* General case */
4550 /* ghcimpl is not currently used
4551 class->ghcimpl = 1;
4552 if (class->parent) {
4553 MonoMethod *cmethod = class->vtable [ghc_slot];
4554 if (cmethod->is_inflated)
4555 cmethod = ((MonoMethodInflated*)cmethod)->declaring;
4556 if (cmethod == default_ghc) {
4557 class->ghcimpl = 0;
4558 }
4559 }
4560 */
4562 /* Interfaces and valuetypes are not supposed to have finalizers */
4572 /* FIXME: Optimize this */
4577 }
4580 /* Check that this is really the finalizer method */
4595 }
4596 }
4597 }
4598 }
4599 }
4601 /* C# doesn't allow interfaces to have cctors */
4607 /* The find_method function ignores the 'flags' argument */
4621 }
4622 }
4623 }
4624 }
4625 }
4628 /* This will compute class->parent->vtable_size for some classes */
4633 }
4637 /* FIXME: Get rid of this somehow */
4642 }
4645 }
4649 }
4654 }
4656 }
4660 leave:
4661 /* Because of the double-checking locking pattern */
4672 }
4674 static gboolean
4676 {
4677 /* FIXME: allow the dynamic case for our compilers and with full trust */
4680 else
4682 }
4684 /*
4685 * LOCKING: this assumes the loader lock is held
4686 */
4687 void
4689 {
4702 /*
4703 * do not set the valuetype bit for System.ValueType.
4704 * class->valuetype = 1;
4705 */
4708 /*
4709 * do not set the valuetype bit for System.Enum.
4710 * class->valuetype = 1;
4711 */
4720 }
4721 }
4734 }
4739 }
4745 }
4760 }
4769 }
4784 }
4790 }
4795 }
4799 }
4800 }
4802 }
4807 }
4809 /*
4810 * COM initialization (using mono_init_com_types) is delayed until needed.
4811 * However when a [ComImport] attribute is present on a type it will trigger
4812 * the initialization. This is not a problem unless the BCL being executed
4813 * lacks the types that COM depends on (e.g. Variant on Silverlight).
4814 */
4815 static void
4817 {
4818 /* we don't always allow COM initialization under the CoreCLR (e.g. Moonlight does not require it) */
4820 /* but some other CoreCLR user could requires it for their platform (i.e. trusted) code */
4822 /* but it can not be made available for application (i.e. user code) since all COM calls
4823 * are considered native calls. In this case we fail with a TypeLoadException (just like
4824 * Silverlight 2 does */
4827 }
4828 }
4829 /* FIXME : we should add an extra checks to ensure COM can be initialized properly before continuing */
4831 }
4833 /*
4834 * LOCKING: this assumes the loader lock is held
4835 */
4836 void
4838 {
4839 gboolean system_namespace;
4844 /* if root of the hierarchy */
4849 }
4854 }
4857 /* Imported COM Objects always derive from __ComObject. */
4862 }
4864 /* set the parent to something useful and safe, but mark the type as broken */
4867 }
4872 /*
4873 * If the parent is a generic instance, we may get
4874 * called before it is fully initialized, especially
4875 * before it has its name.
4876 */
4878 }
4885 else
4897 }
4899 if (class->parent->enumtype || (is_corlib_image (class->parent->image) && (strcmp (class->parent->name, "ValueType") == 0) &&
4902 if (is_corlib_image (class->parent->image) && ((strcmp (class->parent->name, "Enum") == 0) && (strcmp (class->parent->name_space, "System") == 0))) {
4904 }
4905 /*class->enumtype = class->parent->enumtype; */
4908 /* initialize com types if COM interfaces are present */
4912 }
4914 }
4916 /*
4917 * mono_class_setup_supertypes:
4918 * @class: a class
4919 *
4920 * Build the data structure needed to make fast type checks work.
4921 * This currently sets two fields in @class:
4922 * - idepth: distance between @class and System.Object in the type
4923 * hierarchy + 1
4924 * - supertypes: array of classes: each element has a class in the hierarchy
4925 * starting from @class up to System.Object
4926 *
4927 * LOCKING: this assumes the loader lock is held
4928 */
4929 void
4931 {
4941 else
4949 memcpy (class->supertypes, class->parent->supertypes, class->parent->idepth * sizeof (gpointer));
4952 }
4953 }
4955 /**
4956 * mono_class_create_from_typedef:
4957 * @image: image where the token is valid
4958 * @type_token: typedef token
4959 *
4960 * Create the MonoClass* representing the specified type token.
4961 * @type_token must be a TypeDef token.
4962 */
4965 {
4976 guint32 nesting_tokeen;
4983 if ((class = mono_internal_hash_table_lookup (&image->class_cache, GUINT_TO_POINTER (type_token)))) {
4986 }
5008 /*
5009 * Check whether we're a generic type definition.
5010 */
5016 }
5022 /*WARNING: this must satisfy mono_metadata_type_hash*/
5028 }
5036 }
5037 }
5039 /* do this early so it's available for interfaces in setup_mono_type () */
5047 }
5048 }
5052 /* uses ->valuetype, which is initialized by mono_class_setup_parent above */
5058 #ifdef HOST_WIN32
5061 #endif
5071 }
5076 }
5078 /*g_print ("Load class %s\n", name);*/
5080 /*
5081 * Compute the field and method lists
5082 */
5093 }
5098 else
5103 else
5106 /* reserve space to store vector pointer in arrays */
5110 }
5119 }
5121 }
5123 /*
5124 * If we're a generic type definition, load the constraints.
5125 * We must do this after the class has been constructed to make certain recursive scenarios
5126 * work.
5127 */
5128 if (class->generic_container && !mono_metadata_load_generic_param_constraints_full (image, type_token, class->generic_container)){
5130 char *error = concat_two_strings_with_zero (class->image, class_name, class->image->assembly_name);
5136 }
5138 if (class->image->assembly_name && !strcmp (class->image->assembly_name, "Mono.Simd") && !strcmp (nspace, "Mono.Simd")) {
5140 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");
5141 }
5148 }
5150 /** is klass Nullable<T>? */
5151 gboolean
5153 {
5156 }
5159 /** if klass is T? return T */
5160 MonoClass*
5162 {
5165 }
5167 /*
5168 * Create the `MonoClass' for an instantiation of a generic type.
5169 * We only do this if we actually need it.
5170 */
5171 MonoClass*
5173 {
5180 }
5188 /*
5189 * FIXME: the nested type context should include everything the
5190 * nesting context should have, but it may also have additional
5191 * generic parameters...
5192 */
5195 }
5221 /*
5222 * We're not interested in the nested classes of a generic instance.
5223 * We use the generic type definition to look for nested classes.
5224 */
5227 klass->parent = mono_class_inflate_generic_class (gklass->parent, mono_generic_class_get_context (gclass));
5228 }
5236 }
5244 /*
5245 * For enums, gklass->fields might not been set, but instance_size etc. is
5246 * already set in mono_reflection_create_internal_class (). For non-enums,
5247 * these will be computed normally in mono_class_layout_fields ().
5248 */
5252 }
5253 }
5257 inflated_classes ++;
5263 }
5266 make_generic_param_class (MonoGenericParam *param, MonoImage *image, gboolean is_mvar, MonoGenericParamInfo *pinfo)
5267 {
5273 /* FIXME: */
5285 }
5294 }
5297 }
5304 ;
5309 pos++;
5312 else
5322 }
5334 /* FIXME: shouldn't this be ->type_token? */
5343 }
5346 }
5348 #define FAST_CACHE_SIZE 16
5356 {
5364 }
5366 static void
5368 {
5375 }
5381 else
5383 }
5386 }
5388 /*
5389 * LOCKING: Acquires the loader lock.
5390 */
5391 MonoClass *
5392 mono_class_from_generic_parameter (MonoGenericParam *param, MonoImage *image, gboolean is_mvar)
5393 {
5405 }
5414 }
5415 }
5423 // FIXME: 'klass' should not be null
5424 // But, monodis creates GenericContainers without associating a owner to it
5426 }
5427 }
5435 else
5440 /* FIXME: Should this go inside 'make_generic_param_klass'? */
5444 }
5446 MonoClass *
5448 {
5465 }
5481 /* Can pointers get boxed? */
5499 }
5503 {
5507 /* FIXME: These should be allocate from a mempool as well, but which one ? */
5517 }
5528 result->flags = TYPE_ATTRIBUTE_CLASS; /* | (el_class->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK); */
5529 /* Can pointers get boxed? */
5548 }
5550 MonoClass *
5552 {
5610 }
5613 }
5615 /**
5616 * mono_type_retrieve_from_typespec
5617 * @image: context where the image is created
5618 * @type_spec: typespec token
5619 * @context: the generic context used to evaluate generic instantiations in
5620 */
5622 mono_type_retrieve_from_typespec (MonoImage *image, guint32 type_spec, MonoGenericContext *context, gboolean *did_inflate, MonoError *error)
5623 {
5632 mono_error_set_type_load_name (error, name, assembly, "Could not resolve typespec token %08x", type_spec);
5634 }
5645 }
5646 }
5648 }
5650 /**
5651 * mono_class_create_from_typespec
5652 * @image: context where the image is created
5653 * @type_spec: typespec token
5654 * @context: the generic context used to evaluate generic instantiations in
5655 */
5657 mono_class_create_from_typespec (MonoImage *image, guint32 type_spec, MonoGenericContext *context, MonoError *error)
5658 {
5668 }
5670 /**
5671 * mono_bounded_array_class_get:
5672 * @element_class: element class
5673 * @rank: the dimension of the array class
5674 * @bounded: whenever the array has non-zero bounds
5675 *
5676 * Returns: a class object describing the array with element type @element_type and
5677 * dimension @rank.
5678 */
5679 MonoClass *
5681 {
5693 /* bounded only matters for one-dimensional arrays */
5699 /*
5700 * This case is very frequent not just during compilation because of calls
5701 * from mono_class_from_mono_type (), mono_array_new (),
5702 * Array:CreateInstance (), etc, so use a separate cache + a separate lock.
5703 */
5722 if ((class->rank == rank) && (class->byval_arg.type == (((rank > 1) || bounded) ? MONO_TYPE_ARRAY : MONO_TYPE_SZARRAY))) {
5725 }
5726 }
5727 }
5728 }
5730 /* for the building corlib use System.Array from it */
5731 if (image->assembly && image->assembly->dynamic && image->assembly_name && strcmp (image->assembly_name, "mscorlib") == 0) {
5738 }
5762 /* all arrays are marked serializable and sealed, bug #42779 */
5763 class->flags = TYPE_ATTRIBUTE_CLASS | TYPE_ATTRIBUTE_SERIALIZABLE | TYPE_ATTRIBUTE_SEALED | TYPE_ATTRIBUTE_PUBLIC;
5771 }
5772 /* element_size -1 is ok as this is not an instantitable type*/
5783 if (eclass->exception_type) /*FIXME we fail the array type, but we have to let other fields be set.*/
5786 class->has_references = MONO_TYPE_IS_REFERENCE (&eclass->byval_arg) || eclass->has_references? TRUE: FALSE;
5792 else
5803 /* FIXME: complete.... */
5807 }
5812 }
5822 /* Someone got in before us */
5824 else
5830 }
5837 }
5839 /**
5840 * mono_array_class_get:
5841 * @element_class: element class
5842 * @rank: the dimension of the array class
5843 *
5844 * Returns: a class object describing the array with element type @element_type and
5845 * dimension @rank.
5846 */
5847 MonoClass *
5849 {
5851 }
5853 /**
5854 * mono_class_instance_size:
5855 * @klass: a class
5856 *
5857 * Returns: the size of an object instance
5858 */
5859 gint32
5861 {
5866 }
5868 /**
5869 * mono_class_min_align:
5870 * @klass: a class
5871 *
5872 * Returns: minimm alignment requirements
5873 */
5874 gint32
5876 {
5881 }
5883 /**
5884 * mono_class_value_size:
5885 * @klass: a class
5886 *
5887 * This function is used for value types, and return the
5888 * space and the alignment to store that kind of value object.
5889 *
5890 * Returns: the size of a value of kind @klass
5891 */
5892 gint32
5894 {
5895 gint32 size;
5897 /* fixme: check disable, because we still have external revereces to
5898 * mscorlib and Dummy Objects
5899 */
5900 /*g_assert (klass->valuetype);*/
5908 }
5910 /**
5911 * mono_class_data_size:
5912 * @klass: a class
5913 *
5914 * Returns: the size of the static class data
5915 */
5916 gint32
5918 {
5922 /* in arrays, sizes.class_size is unioned with element_size
5923 * and arrays have no static fields
5924 */
5928 }
5930 /*
5931 * Auxiliary routine to mono_class_get_field
5932 *
5933 * Takes a field index instead of a field token.
5934 */
5937 {
5944 /*
5945 * class->field.first points to the FieldPtr table, while idx points into the
5946 * Field table, so we have to do a search.
5947 */
5948 /*FIXME this is broken for types with multiple fields with the same name.*/
5949 const char *name = mono_metadata_string_heap (class->image, mono_metadata_decode_row_col (&class->image->tables [MONO_TABLE_FIELD], idx, MONO_FIELD_NAME));
5960 }
5961 }
5962 }
5964 }
5966 }
5968 /**
5969 * mono_class_get_field:
5970 * @class: the class to lookup the field.
5971 * @field_token: the field token
5972 *
5973 * Returns: A MonoClassField representing the type and offset of
5974 * the field, or a NULL value if the field does not belong to this
5975 * class.
5976 */
5977 MonoClassField *
5979 {
5985 }
5987 /**
5988 * mono_class_get_field_from_name:
5989 * @klass: the class to lookup the field.
5990 * @name: the field name
5991 *
5992 * Search the class @klass and it's parents for a field with the name @name.
5993 *
5994 * Returns: the MonoClassField pointer of the named field or NULL
5995 */
5996 MonoClassField *
5998 {
6000 }
6002 /**
6003 * mono_class_get_field_from_name_full:
6004 * @klass: the class to lookup the field.
6005 * @name: the field name
6006 * @type: the type of the fields. This optional.
6007 *
6008 * Search the class @klass and it's parents for a field with the name @name and type @type.
6009 *
6010 * If @klass is an inflated generic type, the type comparison is done with the equivalent field
6011 * of its generic type definition.
6012 *
6013 * Returns: the MonoClassField pointer of the named field or NULL
6014 */
6015 MonoClassField *
6017 {
6032 MonoType *field_type = mono_metadata_get_corresponding_field_from_generic_type_definition (field)->type;
6035 }
6037 }
6039 }
6041 }
6043 /**
6044 * mono_class_get_field_token:
6045 * @field: the field we need the token of
6046 *
6047 * Get the token of a field. Note that the tokesn is only valid for the image
6048 * the field was loaded from. Don't use this function for fields in dynamic types.
6049 *
6050 * Returns: the token representing the field in the image it was loaded from.
6051 */
6052 guint32
6054 {
6070 }
6071 }
6073 }
6077 }
6079 static int
6081 {
6087 }
6089 /*
6090 * mono_class_get_field_default_value:
6091 *
6092 * Return the default value of the field as a pointer into the metadata blob.
6093 */
6096 {
6097 guint32 cindex;
6108 klass->ext->field_def_values = mono_image_alloc0 (klass->image, sizeof (MonoFieldDefaultValue) * klass->field.count);
6110 }
6115 cindex = mono_metadata_get_constant_index (field->parent->image, mono_class_get_field_token (field), 0);
6119 mono_metadata_decode_row (&field->parent->image->tables [MONO_TABLE_CONSTANT], cindex - 1, constant_cols, MONO_CONSTANT_SIZE);
6121 klass->ext->field_def_values [field_index].data = (gpointer)mono_metadata_blob_heap (field->parent->image, constant_cols [MONO_CONSTANT_VALUE]);
6122 }
6126 }
6128 /*
6129 * mono_class_get_property_default_value:
6130 *
6131 * Return the default value of the field as a pointer into the metadata blob.
6132 */
6135 {
6136 guint32 cindex;
6141 /*We don't cache here because it is not used by C# so it's quite rare.*/
6143 cindex = mono_metadata_get_constant_index (klass->image, mono_class_get_property_token (property), 0);
6147 mono_metadata_decode_row (&klass->image->tables [MONO_TABLE_CONSTANT], cindex - 1, constant_cols, MONO_CONSTANT_SIZE);
6150 }
6152 guint32
6154 {
6163 }
6164 }
6166 }
6170 }
6172 MonoProperty*
6174 {
6181 }
6183 }
6185 }
6187 guint32
6189 {
6199 i ++;
6200 }
6202 }
6206 }
6210 {
6229 else
6231 }
6245 else
6247 }
6253 }
6254 }
6258 {
6267 MonoAssemblyName aname;
6280 /* FIXME: */
6283 /* FIXME: */
6286 /* FIXME: */
6293 }
6295 }
6297 /* FIXME: */
6301 }
6304 }
6306 /**
6307 * mono_class_get_full:
6308 * @image: the image where the class resides
6309 * @type_token: the token for the class
6310 * @context: the generic context used to evaluate generic instantiations in
6311 *
6312 * Returns: the MonoClass that represents @type_token in @image
6313 */
6314 MonoClass *
6316 {
6317 MonoError error;
6323 if (table != MONO_TABLE_TYPEDEF && table != MONO_TABLE_TYPEREF && table != MONO_TABLE_TYPESPEC) {
6326 }
6328 }
6340 /*FIXME don't swallow the error message*/
6342 }
6347 }
6353 }
6356 }
6359 /**
6360 * mono_type_get_full:
6361 * @image: the image where the type resides
6362 * @type_token: the token for the type
6363 * @context: the generic context used to evaluate generic instantiations in
6364 *
6365 * This functions exists to fullfill the fact that sometimes it's desirable to have access to the
6366 *
6367 * Returns: the MonoType that represents @type_token in @image
6368 */
6369 MonoType *
6371 {
6372 MonoError error;
6376 //FIXME: this will not fix the very issue for which mono_type_get_full exists -but how to do it then?
6383 }
6388 /*FIXME don't swalloc the error message.*/
6392 g_warning ("Error loading type %s from %s due to %s", name, assembly, mono_error_get_message (&error));
6397 }
6402 /* FIXME: This is a workaround fo the fact that a typespec token sometimes reference to the generic type definition.
6403 * A MonoClass::byval_arg of a generic type definion has type CLASS.
6404 * Some parts of mono create a GENERICINST to reference a generic type definition and this generates confict with byval_arg.
6405 *
6406 * The long term solution is to chaise this places and make then set MonoType::type correctly.
6407 * */
6410 else
6412 }
6414 }
6417 MonoClass *
6419 {
6421 }
6423 /**
6424 * mono_image_init_name_cache:
6425 *
6426 * Initializes the class name cache stored in image->name_cache.
6427 *
6428 * LOCKING: Acquires the corresponding image lock.
6429 */
6430 void
6432 {
6445 }
6452 }
6454 /* Temporary hash table to avoid lookups in the nspace_table */
6460 /*
6461 * Nested types are accessed from the nesting name. We use the fact that nested types use different visibility flags
6462 * than toplevel types, thus avoiding the need to grovel through the NESTED_TYPE table
6463 */
6475 nspace_table);
6476 }
6478 }
6480 /* Load type names from EXPORTEDTYPES table */
6481 {
6497 nspace_table);
6498 }
6499 g_hash_table_insert (nspace_table, (char *) name, GUINT_TO_POINTER (mono_metadata_make_token (MONO_TABLE_EXPORTEDTYPE, i + 1)));
6500 }
6501 }
6505 }
6507 /*FIXME Only dynamic assemblies should allow this operation.*/
6508 void
6511 {
6514 guint32 old_index;
6525 }
6528 g_error ("overrwritting old token %x on image %s for type %s::%s", old_index, image->name, nspace, name);
6533 }
6536 gconstpointer key;
6537 gpointer value;
6540 static void
6542 {
6548 }
6550 /**
6551 * mono_class_from_name_case:
6552 * @image: The MonoImage where the type is looked up in
6553 * @name_space: the type namespace
6554 * @name: the type short name.
6555 *
6556 * Obtains a MonoClass with a given namespace and a given name which
6557 * is located in the given MonoImage. The namespace and name
6558 * lookups are case insensitive.
6559 */
6560 MonoClass *
6562 {
6571 FindUserData user_data;
6592 }
6598 else
6601 }
6603 /* add a cache if needed */
6607 /*
6608 * Nested types are accessed from the nesting name. We use the fact that nested types use different visibility flags
6609 * than toplevel types, thus avoiding the need to grovel through the NESTED_TYPE table
6610 */
6617 }
6619 }
6623 {
6630 s++;
6631 }
6638 }
6639 }
6641 }
6645 {
6651 /*
6652 * The EXPORTEDTYPES table only contains public types, so have to search the
6653 * modules as well.
6654 * Note: image->modules contains the contents of the MODULEREF table, while
6655 * the real module list is in the FILE table.
6656 */
6668 }
6669 }
6672 }
6674 /**
6675 * mono_class_from_name:
6676 * @image: The MonoImage where the type is looked up in
6677 * @name_space: the type namespace
6678 * @name: the type short name.
6679 *
6680 * Obtains a MonoClass with a given namespace and a given name which
6681 * is located in the given MonoImage.
6682 */
6683 MonoClass *
6685 {
6703 }
6712 else
6714 }
6715 }
6730 /* Search modules as well */
6737 }
6738 }
6744 }
6768 guint32 assembly_idx;
6776 else
6777 /* FIXME: Cycle detection */
6781 }
6782 }
6790 }
6792 /*FIXME test for interfaces with variant generic arguments*/
6793 gboolean
6795 gboolean check_interfaces)
6796 {
6798 if (check_interfaces && MONO_CLASS_IS_INTERFACE (klassc) && !MONO_CLASS_IS_INTERFACE (klass)) {
6801 } else if (check_interfaces && MONO_CLASS_IS_INTERFACE (klassc) && MONO_CLASS_IS_INTERFACE (klass)) {
6808 }
6812 }
6814 /*
6815 * MS.NET thinks interfaces are a subclass of Object, so we think it as
6816 * well.
6817 */
6822 }
6824 gboolean
6826 {
6836 if (mono_generic_container_get_param_info (container, i)->flags & (MONO_GEN_PARAM_VARIANT|MONO_GEN_PARAM_COVARIANT))
6840 }
6842 /**
6843 * @container the generic container from the GTD
6844 * @klass: the class to be assigned to
6845 * @oklass: the source class
6846 *
6847 * Both klass and oklass must be instances of the same generic interface.
6848 * Return true if @klass can be assigned to a @klass variable
6849 */
6850 static gboolean
6852 {
6858 /*Viable candidates are instances of the same generic interface*/
6872 /*
6873 * The _VARIANT and _COVARIANT constants should read _COVARIANT and
6874 * _CONTRAVARIANT, but they are in a public header so we can't fix it.
6875 */
6880 } else if (mono_generic_container_get_param_info (container, j)->flags & MONO_GEN_PARAM_COVARIANT) {
6885 }
6886 }
6888 }
6890 /**
6891 * mono_class_is_assignable_from:
6892 * @klass: the class to be assigned to
6893 * @oklass: the source class
6894 *
6895 * Return: true if an instance of object oklass can be assigned to an
6896 * instance of object @klass
6897 */
6898 gboolean
6900 {
6914 /* interface_offsets might not be set for dynamic classes */
6916 /*
6917 * oklass might be a generic type parameter but they have
6918 * interface_offsets set.
6919 */
6922 /* Happens with generic instances of not-yet created dynamic types */
6928 MonoError error;
6934 }
6936 /*klass is a generic variant interface, We need to extract from oklass a list of ifaces which are viable candidates.*/
6942 }
6943 }
6946 if (mono_class_has_variant_generic_params (klass) && mono_class_is_variant_compatible (klass, oklass))
6954 /* vectors vs. one dimensional arrays */
6961 /*
6962 * a is b does not imply a[] is b[] when a is a valuetype, and
6963 * b is a reference type.
6964 */
6971 }
6977 else
6983 }
6985 /*Check if @oklass is variant compatible with @klass.*/
6986 static gboolean
6988 {
6994 /*Viable candidates are instances of the same generic interface*/
7008 /*
7009 * The _VARIANT and _COVARIANT constants should read _COVARIANT and
7010 * _CONTRAVARIANT, but they are in a public header so we can't fix it.
7011 */
7016 } else if (mono_generic_container_get_param_info (container, j)->flags & MONO_GEN_PARAM_COVARIANT) {
7021 }
7022 }
7024 }
7025 /*Check if @candidate implements the interface @target*/
7026 static gboolean
7028 {
7029 MonoError error;
7036 }
7042 /*A TypeBuilder can have more interfaces on tb->interfaces than on candidate->interfaces*/
7056 }
7057 }
7059 /*setup_interfaces don't mono_class_init anything*/
7064 }
7075 }
7076 }
7081 }
7083 /*
7084 * Check if @oklass can be assigned to @klass.
7085 * This function does the same as mono_class_is_assignable_from but is safe to be used from mono_class_init context.
7086 */
7087 gboolean
7089 {
7095 /*setup_supertypes don't mono_class_init anything */
7102 /*If target is not an interface there is no need to check them.*/
7109 /*FIXME properly handle nullables and arrays */
7112 }
7114 /**
7115 * mono_class_get_cctor:
7116 * @klass: A MonoClass pointer
7117 *
7118 * Returns: the static constructor of @klass if it exists, NULL otherwise.
7119 */
7120 MonoMethod*
7122 {
7123 MonoCachedClassInfo cached_info;
7126 /*
7127 * has_cctor is not set for these classes because mono_class_init () is
7128 * not run for them.
7129 */
7130 return mono_class_get_method_from_name_flags (klass, ".cctor", -1, METHOD_ATTRIBUTE_SPECIAL_NAME);
7131 }
7140 return mono_class_get_inflated_method (klass, mono_class_get_cctor (klass->generic_class->container_class));
7142 return mono_class_get_method_from_name_flags (klass, ".cctor", -1, METHOD_ATTRIBUTE_SPECIAL_NAME);
7143 }
7145 /**
7146 * mono_class_get_finalizer:
7147 * @klass: The MonoClass pointer
7148 *
7149 * Returns: the finalizer method of @klass if it exists, NULL otherwise.
7150 */
7151 MonoMethod*
7153 {
7154 MonoCachedClassInfo cached_info;
7166 }
7167 }
7169 /**
7170 * mono_class_needs_cctor_run:
7171 * @klass: the MonoClass pointer
7172 * @caller: a MonoMethod describing the caller
7173 *
7174 * Determines whenever the class has a static constructor and whenever it
7175 * needs to be called when executing CALLER.
7176 */
7177 gboolean
7179 {
7185 else
7187 }
7189 /**
7190 * mono_class_array_element_size:
7191 * @klass:
7192 *
7193 * Returns: the number of bytes an element of type @klass
7194 * uses when stored into an array.
7195 */
7196 gint32
7198 {
7201 handle_enum:
7235 }
7246 }
7248 }
7250 /**
7251 * mono_array_element_size:
7252 * @ac: pointer to a #MonoArrayClass
7253 *
7254 * Returns: the size of single array element.
7255 */
7256 gint32
7258 {
7261 }
7263 gpointer
7266 {
7269 gpointer obj = mono_lookup_dynamic_token_class (image, token, TRUE, &tmp_handle_class, context);
7277 else
7279 }
7292 /* We return a MonoType* as handle */
7294 }
7307 }
7315 }
7319 mono_metadata_decode_row (&image->tables [MONO_TABLE_MEMBERREF], mono_metadata_token_index (token) - 1, cols, MONO_MEMBERREF_SIZE);
7335 }
7336 }
7340 }
7342 }
7344 /**
7345 * This function might need to call runtime functions so it can't be part
7346 * of the metadata library.
7347 */
7350 void
7352 {
7354 }
7356 gpointer
7358 {
7362 }
7364 gpointer
7365 mono_lookup_dynamic_token_class (MonoImage *image, guint32 token, gboolean valid_token, MonoClass **handle_class, MonoGenericContext *context)
7366 {
7368 }
7372 void
7374 {
7376 }
7378 static gboolean
7380 {
7383 else
7385 }
7387 void
7389 {
7391 }
7393 MonoImage*
7395 {
7397 }
7399 /**
7400 * mono_class_get_element_class:
7401 * @klass: the MonoClass to act on
7402 *
7403 * Returns: the element class of an array or an enumeration.
7404 */
7405 MonoClass*
7407 {
7409 }
7411 /**
7412 * mono_class_is_valuetype:
7413 * @klass: the MonoClass to act on
7414 *
7415 * Returns: true if the MonoClass represents a ValueType.
7416 */
7417 gboolean
7419 {
7421 }
7423 /**
7424 * mono_class_is_enum:
7425 * @klass: the MonoClass to act on
7426 *
7427 * Returns: true if the MonoClass represents an enumeration.
7428 */
7429 gboolean
7431 {
7433 }
7435 /**
7436 * mono_class_enum_basetype:
7437 * @klass: the MonoClass to act on
7438 *
7439 * Returns: the underlying type representation for an enumeration.
7440 */
7441 MonoType*
7443 {
7445 /* SRE or broken types */
7447 else
7449 }
7451 /**
7452 * mono_class_get_parent
7453 * @klass: the MonoClass to act on
7454 *
7455 * Returns: the parent class for this class.
7456 */
7457 MonoClass*
7459 {
7461 }
7463 /**
7464 * mono_class_get_nesting_type;
7465 * @klass: the MonoClass to act on
7466 *
7467 * Returns: the container type where this type is nested or NULL if this type is not a nested type.
7468 */
7469 MonoClass*
7471 {
7473 }
7475 /**
7476 * mono_class_get_rank:
7477 * @klass: the MonoClass to act on
7478 *
7479 * Returns: the rank for the array (the number of dimensions).
7480 */
7481 int
7483 {
7485 }
7487 /**
7488 * mono_class_get_flags:
7489 * @klass: the MonoClass to act on
7490 *
7491 * The type flags from the TypeDef table from the metadata.
7492 * see the TYPE_ATTRIBUTE_* definitions on tabledefs.h for the
7493 * different values.
7494 *
7495 * Returns: the flags from the TypeDef table.
7496 */
7497 guint32
7499 {
7501 }
7503 /**
7504 * mono_class_get_name
7505 * @klass: the MonoClass to act on
7506 *
7507 * Returns: the name of the class.
7508 */
7511 {
7513 }
7515 /**
7516 * mono_class_get_namespace:
7517 * @klass: the MonoClass to act on
7518 *
7519 * Returns: the namespace of the class.
7520 */
7523 {
7525 }
7527 /**
7528 * mono_class_get_type:
7529 * @klass: the MonoClass to act on
7530 *
7531 * This method returns the internal Type representation for the class.
7532 *
7533 * Returns: the MonoType from the class.
7534 */
7535 MonoType*
7537 {
7539 }
7541 /**
7542 * mono_class_get_type_token
7543 * @klass: the MonoClass to act on
7544 *
7545 * This method returns type token for the class.
7546 *
7547 * Returns: the type token for the class.
7548 */
7549 guint32
7551 {
7553 }
7555 /**
7556 * mono_class_get_byref_type:
7557 * @klass: the MonoClass to act on
7558 *
7559 *
7560 */
7561 MonoType*
7563 {
7565 }
7567 /**
7568 * mono_class_num_fields:
7569 * @klass: the MonoClass to act on
7570 *
7571 * Returns: the number of static and instance fields in the class.
7572 */
7573 int
7575 {
7577 }
7579 /**
7580 * mono_class_num_methods:
7581 * @klass: the MonoClass to act on
7582 *
7583 * Returns: the number of methods in the class.
7584 */
7585 int
7587 {
7589 }
7591 /**
7592 * mono_class_num_properties
7593 * @klass: the MonoClass to act on
7594 *
7595 * Returns: the number of properties in the class.
7596 */
7597 int
7599 {
7603 }
7605 /**
7606 * mono_class_num_events:
7607 * @klass: the MonoClass to act on
7608 *
7609 * Returns: the number of events in the class.
7610 */
7611 int
7613 {
7617 }
7619 /**
7620 * mono_class_get_fields:
7621 * @klass: the MonoClass to act on
7622 *
7623 * This routine is an iterator routine for retrieving the fields in a class.
7624 *
7625 * You must pass a gpointer that points to zero and is treated as an opaque handle to
7626 * iterate over all of the elements. When no more values are
7627 * available, the return value is NULL.
7628 *
7629 * Returns: a @MonoClassField* on each iteration, or NULL when no more fields are available.
7630 */
7631 MonoClassField*
7633 {
7641 /* start from the first */
7645 /* no fields */
7647 }
7648 }
7650 field++;
7653 }
7655 }
7657 /**
7658 * mono_class_get_methods
7659 * @klass: the MonoClass to act on
7660 *
7661 * This routine is an iterator routine for retrieving the fields in a class.
7662 *
7663 * You must pass a gpointer that points to zero and is treated as an opaque handle to
7664 * iterate over all of the elements. When no more values are
7665 * available, the return value is NULL.
7666 *
7667 * Returns: a MonoMethod on each iteration or NULL when no more methods are available.
7668 */
7669 MonoMethod*
7671 {
7680 /*
7681 * We can't fail lookup of methods otherwise the runtime will burst in flames on all sort of places.
7682 * FIXME we should better report this error to the caller
7683 */
7686 /* start from the first */
7691 /* no method */
7693 }
7694 }
7696 method++;
7700 }
7702 }
7704 /*
7705 * mono_class_get_virtual_methods:
7706 *
7707 * Iterate over the virtual methods of KLASS.
7708 *
7709 * LOCKING: Assumes the loader lock is held (because of the klass->methods check).
7710 */
7713 {
7717 if (klass->methods || !MONO_CLASS_HAS_STATIC_METADATA (klass) || mono_debug_using_mono_debugger ()) {
7720 /*
7721 * We can't fail lookup of methods otherwise the runtime will burst in flames on all sort of places.
7722 * FIXME we should better report this error to the caller
7723 */
7726 /* start from the first */
7730 method++;
7731 }
7735 method ++;
7736 }
7742 }
7744 /* Search directly in metadata to avoid calling setup_methods () */
7752 }
7755 guint32 flags;
7757 /* class->method.first points into the methodptr table */
7758 flags = mono_metadata_decode_table_row_col (klass->image, MONO_TABLE_METHOD, klass->method.first + i, MONO_METHOD_FLAGS);
7762 }
7765 res = mono_get_method (klass->image, MONO_TOKEN_METHOD_DEF | (klass->method.first + i + 1), klass);
7766 /* Add 1 here so the if (*iter) check fails */
7771 }
7772 }
7773 }
7775 /**
7776 * mono_class_get_properties:
7777 * @klass: the MonoClass to act on
7778 *
7779 * This routine is an iterator routine for retrieving the properties in a class.
7780 *
7781 * You must pass a gpointer that points to zero and is treated as an opaque handle to
7782 * iterate over all of the elements. When no more values are
7783 * available, the return value is NULL.
7784 *
7785 * Returns: a @MonoProperty* on each invocation, or NULL when no more are available.
7786 */
7787 MonoProperty*
7789 {
7797 /* start from the first */
7801 /* no fields */
7803 }
7804 }
7806 property++;
7809 }
7811 }
7813 /**
7814 * mono_class_get_events:
7815 * @klass: the MonoClass to act on
7816 *
7817 * This routine is an iterator routine for retrieving the properties in a class.
7818 *
7819 * You must pass a gpointer that points to zero and is treated as an opaque handle to
7820 * iterate over all of the elements. When no more values are
7821 * available, the return value is NULL.
7822 *
7823 * Returns: a @MonoEvent* on each invocation, or NULL when no more are available.
7824 */
7825 MonoEvent*
7827 {
7835 /* start from the first */
7839 /* no fields */
7841 }
7842 }
7844 event++;
7847 }
7849 }
7851 /**
7852 * mono_class_get_interfaces
7853 * @klass: the MonoClass to act on
7854 *
7855 * This routine is an iterator routine for retrieving the interfaces implemented by this class.
7856 *
7857 * You must pass a gpointer that points to zero and is treated as an opaque handle to
7858 * iterate over all of the elements. When no more values are
7859 * available, the return value is NULL.
7860 *
7861 * Returns: a @Monoclass* on each invocation, or NULL when no more are available.
7862 */
7863 MonoClass*
7865 {
7866 MonoError error;
7878 }
7879 }
7880 /* start from the first */
7885 /* no interface */
7887 }
7888 }
7890 iface++;
7894 }
7896 }
7898 /**
7899 * mono_class_get_nested_types
7900 * @klass: the MonoClass to act on
7901 *
7902 * This routine is an iterator routine for retrieving the nested types of a class.
7903 * This works only if @klass is non-generic, or a generic type definition.
7904 *
7905 * You must pass a gpointer that points to zero and is treated as an opaque handle to
7906 * iterate over all of the elements. When no more values are
7907 * available, the return value is NULL.
7908 *
7909 * Returns: a @Monoclass* on each invocation, or NULL when no more are available.
7910 */
7911 MonoClass*
7913 {
7930 mono_metadata_decode_row (&klass->image->tables [MONO_TABLE_NESTEDCLASS], i - 1, cols, MONO_NESTED_CLASS_SIZE);
7931 nclass = mono_class_create_from_typedef (klass->image, MONO_TOKEN_TYPE_DEF | cols [MONO_NESTED_CLASS_NESTED]);
7935 klass->ext->nested_classes = g_list_prepend_image (klass->image, klass->ext->nested_classes, nclass);
7938 }
7939 }
7943 }
7946 /* start from the first */
7951 /* no nested types */
7953 }
7954 }
7960 }
7962 }
7964 /**
7965 * mono_field_get_name:
7966 * @field: the MonoClassField to act on
7967 *
7968 * Returns: the name of the field.
7969 */
7972 {
7974 }
7976 /**
7977 * mono_field_get_type:
7978 * @field: the MonoClassField to act on
7979 *
7980 * Returns: MonoType of the field.
7981 */
7982 MonoType*
7984 {
7986 }
7988 /**
7989 * mono_field_get_parent:
7990 * @field: the MonoClassField to act on
7991 *
7992 * Returns: MonoClass where the field was defined.
7993 */
7994 MonoClass*
7996 {
7998 }
8000 /**
8001 * mono_field_get_flags;
8002 * @field: the MonoClassField to act on
8003 *
8004 * The metadata flags for a field are encoded using the
8005 * FIELD_ATTRIBUTE_* constants. See the tabledefs.h file for details.
8006 *
8007 * Returns: the flags for the field.
8008 */
8009 guint32
8011 {
8013 }
8015 /**
8016 * mono_field_get_offset;
8017 * @field: the MonoClassField to act on
8018 *
8019 * Returns: the field offset.
8020 */
8021 guint32
8023 {
8025 }
8029 {
8030 guint32 rva;
8040 klass->ext->field_def_values = mono_image_alloc0 (klass->image, sizeof (MonoFieldDefaultValue) * klass->field.count);
8042 }
8047 mono_metadata_field_info (field->parent->image, klass->field.first + field_index, NULL, &rva, NULL);
8049 g_warning ("field %s in %s should have RVA data, but hasn't", mono_field_get_name (field), field->parent->name);
8050 klass->ext->field_def_values [field_index].data = mono_image_rva_map (field->parent->image, rva);
8051 }
8054 }
8056 /**
8057 * mono_field_get_data;
8058 * @field: the MonoClassField to act on
8059 *
8060 * Returns: pointer to the metadata constant value or to the field
8061 * data if it has an RVA flag.
8062 */
8065 {
8067 MonoTypeEnum def_type;
8074 }
8075 }
8077 /**
8078 * mono_property_get_name:
8079 * @prop: the MonoProperty to act on
8080 *
8081 * Returns: the name of the property
8082 */
8085 {
8087 }
8089 /**
8090 * mono_property_get_set_method
8091 * @prop: the MonoProperty to act on.
8092 *
8093 * Returns: the setter method of the property (A MonoMethod)
8094 */
8095 MonoMethod*
8097 {
8099 }
8101 /**
8102 * mono_property_get_get_method
8103 * @prop: the MonoProperty to act on.
8104 *
8105 * Returns: the setter method of the property (A MonoMethod)
8106 */
8107 MonoMethod*
8109 {
8111 }
8113 /**
8114 * mono_property_get_parent:
8115 * @prop: the MonoProperty to act on.
8116 *
8117 * Returns: the MonoClass where the property was defined.
8118 */
8119 MonoClass*
8121 {
8123 }
8125 /**
8126 * mono_property_get_flags:
8127 * @prop: the MonoProperty to act on.
8128 *
8129 * The metadata flags for a property are encoded using the
8130 * PROPERTY_ATTRIBUTE_* constants. See the tabledefs.h file for details.
8131 *
8132 * Returns: the flags for the property.
8133 */
8134 guint32
8136 {
8138 }
8140 /**
8141 * mono_event_get_name:
8142 * @event: the MonoEvent to act on
8143 *
8144 * Returns: the name of the event.
8145 */
8148 {
8150 }
8152 /**
8153 * mono_event_get_add_method:
8154 * @event: The MonoEvent to act on.
8155 *
8156 * Returns: the @add' method for the event (a MonoMethod).
8157 */
8158 MonoMethod*
8160 {
8162 }
8164 /**
8165 * mono_event_get_remove_method:
8166 * @event: The MonoEvent to act on.
8167 *
8168 * Returns: the @remove method for the event (a MonoMethod).
8169 */
8170 MonoMethod*
8172 {
8174 }
8176 /**
8177 * mono_event_get_raise_method:
8178 * @event: The MonoEvent to act on.
8179 *
8180 * Returns: the @raise method for the event (a MonoMethod).
8181 */
8182 MonoMethod*
8184 {
8186 }
8188 /**
8189 * mono_event_get_parent:
8190 * @event: the MonoEvent to act on.
8191 *
8192 * Returns: the MonoClass where the event is defined.
8193 */
8194 MonoClass*
8196 {
8198 }
8200 /**
8201 * mono_event_get_flags
8202 * @event: the MonoEvent to act on.
8203 *
8204 * The metadata flags for an event are encoded using the
8205 * EVENT_* constants. See the tabledefs.h file for details.
8206 *
8207 * Returns: the flags for the event.
8208 */
8209 guint32
8211 {
8213 }
8215 /**
8216 * mono_class_get_method_from_name:
8217 * @klass: where to look for the method
8218 * @name_space: name of the method
8219 * @param_count: number of parameters. -1 for any number.
8220 *
8221 * Obtains a MonoMethod with a given name and number of parameters.
8222 * It only works if there are no multiple signatures for any given method name.
8223 */
8224 MonoMethod *
8226 {
8228 }
8232 {
8236 /* Search directly in the metadata to avoid calling setup_methods () */
8241 /* class->method.first points into the methodptr table */
8242 mono_metadata_decode_table_row (klass->image, MONO_TABLE_METHOD, klass->method.first + i, cols, MONO_METHOD_SIZE);
8245 method = mono_get_method (klass->image, MONO_TOKEN_METHOD_DEF | (klass->method.first + i + 1), klass);
8249 }
8250 }
8251 }
8254 }
8256 /**
8257 * mono_class_get_method_from_name_flags:
8258 * @klass: where to look for the method
8259 * @name_space: name of the method
8260 * @param_count: number of parameters. -1 for any number.
8261 * @flags: flags which must be set in the method
8262 *
8263 * Obtains a MonoMethod with a given name and number of parameters.
8264 * It only works if there are no multiple signatures for any given method name.
8265 */
8266 MonoMethod *
8267 mono_class_get_method_from_name_flags (MonoClass *klass, const char *name, int param_count, int flags)
8268 {
8275 res = mono_class_get_method_from_name_flags (klass->generic_class->container_class, name, param_count, flags);
8279 }
8283 /*
8284 We can't fail lookup of methods otherwise the runtime will burst in flames on all sort of places.
8285 See mono/tests/array_load_exception.il
8286 FIXME we should better report this error to the caller
8287 */
8299 }
8300 }
8301 }
8304 }
8307 }
8309 /**
8310 * mono_class_set_failure:
8311 * @klass: class in which the failure was detected
8312 * @ex_type: the kind of exception/error to be thrown (later)
8313 * @ex_data: exception data (specific to each type of exception/error)
8314 *
8315 * Keep a detected failure informations in the class for later processing.
8316 * Note that only the first failure is kept.
8317 *
8318 * LOCKING: Acquires the loader lock.
8319 */
8320 gboolean
8322 {
8333 }
8335 /*
8336 * mono_class_get_exception_data:
8337 *
8338 * Return the exception_data property of KLASS.
8339 *
8340 * LOCKING: Acquires the loader lock.
8341 */
8342 gpointer
8344 {
8346 }
8348 /**
8349 * mono_classes_init:
8350 *
8351 * Initialize the resources used by this module.
8352 */
8353 void
8355 {
8366 }
8368 /**
8369 * mono_classes_cleanup:
8370 *
8371 * Free the resources used by this module.
8372 */
8373 void
8375 {
8378 }
8380 /**
8381 * mono_class_get_exception_for_failure:
8382 * @klass: class in which the failure was detected
8383 *
8384 * Return a constructed MonoException than the caller can then throw
8385 * using mono_raise_exception - or NULL if no failure is present (or
8386 * doesn't result in an exception).
8387 */
8388 MonoException*
8390 {
8398 guint32 error = (method) ? MONO_METADATA_INHERITANCEDEMAND_METHOD : MONO_METADATA_INHERITANCEDEMAND_CLASS;
8409 }
8414 char *astr = klass->image->assembly? mono_stringify_assembly_name (&klass->image->assembly->aname): NULL;
8420 }
8426 }
8432 }
8439 ex = mono_get_exception_file_not_found2 (msg, mono_string_new (mono_domain_get (), assembly_name));
8444 }
8447 }
8456 }
8458 /* TODO - handle other class related failures */
8460 }
8461 }
8462 }
8464 static gboolean
8466 {
8475 }
8477 MonoClass *
8479 {
8481 }
8483 /*
8484 * Check if @klass is a subtype of @parent ignoring generic instantiations.
8485 *
8486 * Generic instantiations are ignored for all super types of @klass.
8487 *
8488 * Visibility checks ignoring generic instantiations.
8489 */
8490 gboolean
8492 {
8500 }
8502 }
8503 /*
8504 * Subtype can only access parent members with family protection if the site object
8505 * is subclass of Subtype. For example:
8506 * class A { protected int x; }
8507 * class B : A {
8508 * void valid_access () {
8509 * B b;
8510 * b.x = 0;
8511 * }
8512 * void invalid_access () {
8513 * A a;
8514 * a.x = 0;
8515 * }
8516 * }
8517 * */
8518 static gboolean
8519 is_valid_family_access (MonoClass *access_klass, MonoClass *member_klass, MonoClass *context_klass)
8520 {
8526 /*if access_klass is not member_klass context_klass must be type compat*/
8527 if (access_klass != member_klass && !mono_class_has_parent_and_ignore_generics (context_klass, access_klass))
8530 }
8532 static gboolean
8534 {
8541 /* extra safety under CoreCLR - the runtime does not verify the strongname signatures
8542 * anywhere so untrusted friends are not safe to access platform's code internals */
8546 }
8551 /* Be conservative with checks */
8559 if (!mono_public_tokens_are_equal (friend->public_key_token, accessing->aname.public_key_token))
8561 }
8563 }
8565 }
8567 /*
8568 * If klass is a generic type or if it is derived from a generic type, return the
8569 * MonoClass of the generic definition
8570 * Returns NULL if not found
8571 */
8574 {
8579 }
8581 }
8583 static gboolean
8585 {
8607 }
8608 }
8610 }
8612 static gboolean
8614 {
8625 if (member_klass->byval_arg.type == MONO_TYPE_VAR || member_klass->byval_arg.type == MONO_TYPE_MVAR)
8628 if (member_klass->generic_class && !can_access_instantiation (access_klass, member_klass->generic_class->context.class_inst))
8631 if (is_nesting_type (access_klass, member_klass) || (access_klass->nested_in && is_nesting_type (access_klass->nested_in, member_klass)))
8637 /*Non nested type with nested visibility. We just fail it.*/
8638 if (access_level >= TYPE_ATTRIBUTE_NESTED_PRIVATE && access_level <= TYPE_ATTRIBUTE_NESTED_FAM_OR_ASSEM && member_klass->nested_in == NULL)
8661 return can_access_internals (access_klass->image->assembly, member_klass->nested_in->image->assembly) &&
8665 return can_access_internals (access_klass->image->assembly, member_klass->nested_in->image->assembly) ||
8667 }
8669 }
8671 /* FIXME: check visibility of type, too */
8672 static gboolean
8673 can_access_member (MonoClass *access_klass, MonoClass *member_klass, MonoClass* context_klass, int access_level)
8674 {
8683 else
8688 }
8690 /* Partition I 8.5.3.2 */
8691 /* the access level values are the same for fields and methods */
8694 /* same compilation unit */
8715 }
8717 }
8719 gboolean
8721 {
8722 /* FIXME: check all overlapping fields */
8723 int can = can_access_member (method->klass, field->parent, NULL, field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK);
8727 can = can_access_member (nested, field->parent, NULL, field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK);
8731 }
8732 }
8734 }
8736 gboolean
8738 {
8739 int can = can_access_member (method->klass, called->klass, NULL, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
8743 can = can_access_member (nested, called->klass, NULL, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
8747 }
8748 }
8749 /*
8750 * FIXME:
8751 * with generics calls to explicit interface implementations can be expressed
8752 * directly: the method is private, but we must allow it. This may be opening
8753 * a hole or the generics code should handle this differently.
8754 * Maybe just ensure the interface type is public.
8755 */
8759 }
8761 /*
8762 * mono_method_can_access_method_full:
8763 * @method: The caller method
8764 * @called: The called method
8765 * @context_klass: The static type on stack of the owner @called object used
8766 *
8767 * This function must be used with instance calls, as they have more strict family accessibility.
8768 * It can be used with static methods, but context_klass should be NULL.
8769 *
8770 * Returns: TRUE if caller have proper visibility and acessibility to @called
8771 */
8772 gboolean
8773 mono_method_can_access_method_full (MonoMethod *method, MonoMethod *called, MonoClass *context_klass)
8774 {
8777 int can = can_access_member (access_class, member_class, context_klass, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
8781 can = can_access_member (nested, member_class, context_klass, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
8785 }
8786 }
8791 if (!can_access_type (access_class, member_class) && (!access_class->nested_in || !can_access_type (access_class->nested_in, member_class)))
8796 if (infl->context.method_inst && !can_access_instantiation (access_class, infl->context.method_inst))
8798 }
8801 }
8804 /*
8805 * mono_method_can_access_field_full:
8806 * @method: The caller method
8807 * @field: The accessed field
8808 * @context_klass: The static type on stack of the owner @field object used
8809 *
8810 * This function must be used with instance fields, as they have more strict family accessibility.
8811 * It can be used with static fields, but context_klass should be NULL.
8812 *
8813 * Returns: TRUE if caller have proper visibility and acessibility to @field
8814 */
8815 gboolean
8816 mono_method_can_access_field_full (MonoMethod *method, MonoClassField *field, MonoClass *context_klass)
8817 {
8820 /* FIXME: check all overlapping fields */
8821 int can = can_access_member (access_class, member_class, context_klass, field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK);
8825 can = can_access_member (nested, member_class, context_klass, field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK);
8829 }
8830 }
8835 if (!can_access_type (access_class, member_class) && (!access_class->nested_in || !can_access_type (access_class->nested_in, member_class)))
8838 }
8840 /**
8841 * mono_type_is_valid_enum_basetype:
8842 * @type: The MonoType to check
8843 *
8844 * Returns: TRUE if the type can be used as the basetype of an enum
8845 */
8861 }
8863 }
8865 /**
8866 * mono_class_is_valid_enum:
8867 * @klass: An enum class to be validated
8868 *
8869 * This method verify the required properties an enum should have.
8870 *
8871 * Returns: TRUE if the informed enum class is valid
8872 *
8873 * FIXME: TypeBuilder enums are allowed to implement interfaces, but since they cannot have methods, only empty interfaces are possible
8874 * FIXME: enum types are not allowed to have a cctor, but mono_reflection_create_runtime_class sets has_cctor to 1 for all types
8875 * FIXME: TypeBuilder enums can have any kind of static fields, but the spec is very explicit about that (P II 14.3)
8876 */
8883 /* we cannot test against mono_defaults.enum_class, or mcs won't be able to compile the System namespace*/
8884 if (!klass->parent || strcmp (klass->parent->name, "Enum") || strcmp (klass->parent->name_space, "System") ) {
8886 }
8898 }
8899 }
8908 }
8910 gboolean
8912 {
8913 return gklass->context.class_inst == gklass->container_class->generic_container->context.class_inst;
8914 }
8916 /*
8917 * mono_class_setup_interface_id:
8918 *
8919 * Initializes MonoClass::interface_id if required.
8920 *
8921 * LOCKING: Acquires the loader lock.
8922 */
8923 void
8925 {
8930 }
8932 /*
8933 * mono_class_alloc_ext:
8934 *
8935 * Allocate klass->ext if not already done.
8936 * LOCKING: Assumes the loader lock is held.
8937 */
8938 void
8940 {
8946 }
8948 }
8949 }
8951 /*
8952 * mono_class_setup_interfaces:
8953 *
8954 * Initialize class->interfaces/interfaces_count.
8955 * LOCKING: Acquires the loader lock.
8956 * This function can fail the type.
8957 */
8958 void
8960 {
8973 }
8975 if (klass->rank == 1 && klass->byval_arg.type != MONO_TYPE_ARRAY && mono_defaults.generic_ilist_class) {
8978 /* generic IList, ICollection, IEnumerable */
8980 klass->interfaces = mono_image_alloc0 (klass->image, sizeof (MonoClass*) * klass->interface_count);
8991 klass->interfaces [i] = mono_class_inflate_generic_class_checked (gklass->interfaces [i], mono_generic_class_get_context (klass->generic_class), error);
8993 mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Could not setup the interfaces"));
8997 }
8998 }
8999 }
9006 }