| blob | 8a26e59447034727ed7c90bb367ab7f3ea97ae4c |
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;
175 mono_loader_set_error_assembly_load (human_name, image->assembly ? image->assembly->ref_only : FALSE);
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, MonoError *error)
748 {
756 }
763 }
766 mono_class_inflate_generic_class_checked (MonoClass *gklass, MonoGenericContext *context, MonoError *error)
767 {
779 }
780 /*
781 * mono_class_inflate_generic_class:
782 *
783 * Inflate the class GKLASS with CONTEXT.
784 */
785 MonoClass*
787 {
788 MonoError error;
795 }
799 static MonoGenericContext
800 inflate_generic_context (MonoGenericContext *context, MonoGenericContext *inflate_with, MonoError *error)
801 {
812 }
818 }
822 fail:
824 }
826 /*
827 * mono_class_inflate_generic_method:
828 * @method: a generic method
829 * @context: a generics context
830 *
831 * Instantiate the generic method @method using the generics context @context.
832 *
833 * Returns: the new instantiated method
834 */
835 MonoMethod *
837 {
839 }
841 /**
842 * mono_class_inflate_generic_method_full:
843 *
844 * Instantiate method @method with the generic context @context.
845 * BEWARE: All non-trivial fields are invalid, including klass, signature, and header.
846 * Use mono_method_signature () and mono_method_get_header () to get the correct values.
847 */
848 MonoMethod*
849 mono_class_inflate_generic_method_full (MonoMethod *method, MonoClass *klass_hint, MonoGenericContext *context)
850 {
851 MonoError error;
852 MonoMethod *res = mono_class_inflate_generic_method_full_checked (method, klass_hint, context, &error);
854 /*FIXME do proper error handling - on this case, kill this function. */
858 }
860 /**
861 * mono_class_inflate_generic_method_full_checked:
862 * Same as mono_class_inflate_generic_method_full but return failure using @error.
863 */
864 MonoMethod*
865 mono_class_inflate_generic_method_full_checked (MonoMethod *method, MonoClass *klass_hint, MonoGenericContext *context, MonoError *error)
866 {
870 MonoGenericContext tmp_context;
875 /* The `method' has already been instantiated before => we need to peel out the instantiation and create a new context */
889 }
894 /*
895 * The reason for this hack is to fix the behavior of inflating generic methods that come from a MethodBuilder.
896 * What happens is that instantiating a generic MethodBuilder with its own arguments should create a diferent object.
897 * This is opposite to the way non-SRE MethodInfos behave.
898 *
899 * This happens, for example, when we want to emit a recursive generic method. Given the following C# code:
900 *
901 * void Example<T> () {
902 * Example<T> ();
903 * }
904 *
905 * In Example, the method token must be encoded as: "void Example<!!0>()"
906 *
907 * The reference to the first generic argument, "!!0", must be explicit otherwise it won't be inflated
908 * properly. To get that we need to inflate the MethodBuilder with its own arguments.
909 *
910 * On the other hand, inflating a non-SRE generic method with its own arguments should
911 * return itself. For example:
912 *
913 * MethodInfo m = ... //m is a generic method definition
914 * MethodInfo res = m.MakeGenericMethod (m.GetGenericArguments ());
915 * res == m
916 *
917 * To allow such scenarios we must allow inflation of MethodBuilder to happen in a diferent way than
918 * what happens with regular methods.
919 *
920 * There is one last touch to this madness, once a TypeBuilder is finished, IOW CreateType() is called,
921 * everything should behave like a regular type or method.
922 *
923 */
925 method->klass->image->dynamic && !method->klass->wastypebuilder && /* that is a MethodBuilder from an unfinished TypeBuilder */
926 context->method_inst == mono_method_get_generic_container (method)->context.method_inst; /* and it's been instantiated with its own arguments. */
942 }
950 }
959 mono_error_set_bad_image (error, method->klass->image, "Could not resolve signature of method %s:%s", name, method->name);
962 }
968 }
978 /* Set the generic_container of the result to the generic_container of method */
984 }
985 }
1003 }
1009 fail:
1013 }
1015 /**
1016 * mono_get_inflated_method:
1017 *
1018 * Obsolete. We keep it around since it's mentioned in the public API.
1019 */
1020 MonoMethod*
1022 {
1024 }
1026 /*
1027 * mono_method_get_context_general:
1028 * @method: a method
1029 * @uninflated: handle uninflated methods?
1030 *
1031 * Returns the generic context of a method or NULL if it doesn't have
1032 * one. For an inflated method that's the context stored in the
1033 * method. Otherwise it's in the method's generic container or in the
1034 * generic container of the method's class.
1035 */
1036 MonoGenericContext*
1038 {
1042 }
1050 }
1052 /*
1053 * mono_method_get_context:
1054 * @method: a method
1055 *
1056 * Returns the generic context for method if it's inflated, otherwise
1057 * NULL.
1058 */
1059 MonoGenericContext*
1061 {
1063 }
1065 /*
1066 * mono_method_get_generic_container:
1067 *
1068 * Returns the generic container of METHOD, which should be a generic method definition.
1069 * Returns NULL if METHOD is not a generic method definition.
1070 * LOCKING: Acquires the loader lock.
1071 */
1072 MonoGenericContainer*
1074 {
1080 container = mono_image_property_lookup (method->klass->image, method, MONO_METHOD_PROP_GENERIC_CONTAINER);
1084 }
1086 /*
1087 * mono_method_set_generic_container:
1088 *
1089 * Sets the generic container of METHOD to CONTAINER.
1090 * LOCKING: Acquires the loader lock.
1091 */
1092 void
1094 {
1097 mono_image_property_insert (method->klass->image, method, MONO_METHOD_PROP_GENERIC_CONTAINER, container);
1098 }
1100 /**
1101 * mono_class_find_enum_basetype:
1102 * @class: The enum class
1103 *
1104 * Determine the basetype of an enum by iterating through its fields. We do this
1105 * in a separate function since it is cheaper than calling mono_class_setup_fields.
1106 */
1109 {
1124 }
1126 /*
1127 * Fetch all the field information.
1128 */
1135 /* class->field.first and idx points into the fieldptr table */
1146 /* FIELD signature == 0x06 */
1150 ftype = mono_metadata_parse_type_full (m, container, MONO_PARSE_FIELD, cols [MONO_FIELD_FLAGS], sig + 1, &sig);
1154 //FIXME do we leak here?
1157 }
1160 }
1163 }
1165 /*
1166 * Checks for MonoClass::exception_type without resolving all MonoType's into MonoClass'es
1167 */
1168 static gboolean
1170 {
1180 }
1182 }
1184 /**
1185 * mono_class_setup_fields:
1186 * @class: The class to initialize
1187 *
1188 * Initializes the class->fields.
1189 * LOCKING: Assumes the loader lock is held.
1190 */
1191 static void
1193 {
1194 MonoError error;
1201 gboolean explicit_size;
1209 if (class->generic_class && class->generic_class->container_class->image->dynamic && !class->generic_class->container_class->wastypebuilder) {
1210 /*
1211 * This happens when a generic instance of an unfinished generic typebuilder
1212 * is used as an element type for creating an array type. We can't initialize
1213 * the fields of this class using the fields of gklass, since gklass is not
1214 * finished yet, fields could be added to it later.
1215 */
1217 }
1224 }
1229 }
1236 /* For generic instances, class->parent might not have been initialized */
1243 }
1244 }
1247 /* we use |= since it may have been set already */
1253 }
1255 /* We can't really enable 16 bytes alignment until the GC supports it.
1256 The whole layout/instance size code must be reviewed because we do alignment calculation in terms of the
1257 boxed instance, which leads to unexplainable holes at the beginning of an object embedding a simd type.
1258 Bug #506144 is an example of this issue.
1260 if (class->simd_type)
1261 class->min_align = 16;
1262 */
1263 /* Get the real size */
1264 explicit_size = mono_metadata_packing_from_typedef (class->image, class->type_token, &packing_size, &real_size);
1270 }
1275 }
1279 }
1284 /* Prevent infinite loops if the class references itself */
1294 }
1296 /*
1297 * Fetch all the field information.
1298 */
1309 /*This memory must come from the image mempool as we don't have a chance to free it.*/
1310 field->type = mono_class_inflate_generic_type_no_copy (class->image, gfield->type, mono_class_get_context (class), &error);
1312 char *err_msg = g_strdup_printf ("Could not load field %d type due to: %s", i, mono_error_get_message (&error));
1317 }
1326 /* class->field.first and idx points into the fieldptr table */
1328 /* The name is needed for fieldrefs */
1333 }
1336 /* FIELD signature == 0x06 */
1338 field->type = mono_metadata_parse_type_full (m, container, MONO_PARSE_FIELD, cols [MONO_FIELD_FLAGS], sig + 1, &sig);
1342 }
1346 guint32 offset;
1351 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Missing field layout info for %s", field->name));
1353 }
1355 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Invalid negative field offset %d for %s", field->offset, field->name));
1357 }
1358 }
1359 }
1361 /* Only do these checks if we still think this type is blittable */
1372 }
1373 }
1376 }
1377 }
1382 }
1393 }
1394 /* The def_value of fields is compute lazily during vtable creation */
1395 }
1405 }
1408 }
1414 /*valuetypes can't be neither bigger than 1Mb or empty. */
1415 if (class->valuetype && (class->instance_size <= 0 || class->instance_size > (0x100000 + sizeof (MonoObject))))
1417 }
1419 /**
1420 * mono_class_setup_fields_locking:
1421 * @class: The class to initialize
1422 *
1423 * Initializes the class->fields array of fields.
1424 * Aquires the loader lock.
1425 */
1426 static void
1428 {
1432 }
1434 /*
1435 * mono_class_has_references:
1436 *
1437 * Returns whenever @klass->has_references is set, initializing it if needed.
1438 * Aquires the loader lock.
1439 */
1440 static gboolean
1442 {
1444 /* Be conservative */
1450 }
1451 }
1453 /* useful until we keep track of gc-references in corlib etc. */
1454 #ifdef HAVE_SGEN_GC
1455 #define IS_GC_REFERENCE(t) FALSE
1456 #else
1457 #define IS_GC_REFERENCE(t) ((t)->type == MONO_TYPE_U && class->image == mono_defaults.corlib)
1458 #endif
1460 /*
1461 * mono_type_get_basic_type_from_generic:
1462 * @type: a type
1463 *
1464 * Returns a closed type corresponding to the possibly open type
1465 * passed to it.
1466 */
1467 MonoType*
1469 {
1470 /* When we do generic sharing we let type variables stand for reference types. */
1474 }
1476 /*
1477 * mono_class_layout_fields:
1478 * @class: a class
1479 *
1480 * Compute the placement of fields inside an object or struct, according to
1481 * the layout rules and set the following fields in @class:
1482 * - has_references (if the class contains instance references firled or structs that contain references)
1483 * - has_static_refs (same, but for static fields)
1484 * - instance_size (size of the object in memory)
1485 * - class_size (size needed for the static fields)
1486 * - size_inited (flag set when the instance_size is set)
1487 *
1488 * LOCKING: this is supposed to be called with the loader lock held.
1489 */
1490 void
1492 {
1500 /*
1501 * When we do generic sharing we need to have layout
1502 * information for open generic classes (either with a generic
1503 * context containing type variables or with a generic
1504 * container), so we don't return in that case anymore.
1505 */
1507 /*
1508 * Enable GC aware auto layout: in this mode, reference
1509 * fields are grouped together inside objects, increasing collector
1510 * performance.
1511 * Requires that all classes whose layout is known to native code be annotated
1512 * with [StructLayout (LayoutKind.Sequential)]
1513 * Value types have gc_aware_layout disabled by default, as per
1514 * what the default is for other runtimes.
1515 */
1516 /* corlib is missing [StructLayout] directives in many places */
1521 /* from System.dll, used in metadata/process.h */
1524 }
1526 /* Compute klass->has_references */
1527 /*
1528 * Process non-static fields first, since static fields might recursively
1529 * refer to the class itself.
1530 */
1539 if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype)))))
1541 }
1542 }
1552 if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype)))))
1554 }
1555 }
1564 if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype))))) {
1567 else
1569 }
1570 }
1572 /*
1573 * Compute field layout and total size (not considering static fields)
1574 */
1582 else
1590 else
1595 gint32 align;
1596 guint32 size;
1609 if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype))))) {
1615 }
1616 }
1620 /* This field is a hack inserted by MCS to empty structures */
1622 }
1626 /* FIXME (LAMESPEC): should we also change the min alignment according to pack? */
1628 /* if the field has managed references, we need to force-align it
1629 * see bug #77788
1630 */
1631 if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype)))))
1639 }
1640 /*TypeBuilders produce all sort of weird things*/
1643 }
1650 }
1651 }
1656 gint32 align;
1657 guint32 size;
1662 /*
1663 * There must be info about all the fields in a type if it
1664 * uses explicit layout.
1665 */
1675 /*
1676 * When we get here, field->offset is already set by the
1677 * loader (for either runtime fields or fields loaded from metadata).
1678 * The offset is from the start of the object: this works for both
1679 * classes and valuetypes.
1680 */
1684 if (MONO_TYPE_IS_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype))))) {
1687 }
1688 }
1690 /*
1691 * Calc max size.
1692 */
1694 }
1697 }
1700 /*
1701 * For small structs, set min_align to at least the struct size to improve
1702 * performance, and since the JIT memset/memcpy code assumes this and generates
1703 * unaligned accesses otherwise. See #78990 for a testcase.
1704 */
1707 }
1711 /*
1712 * Compute static field layout and size
1713 */
1715 gint32 align;
1716 guint32 size;
1720 if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC) || field->type->attrs & FIELD_ATTRIBUTE_LITERAL)
1728 }
1732 /*align is always non-zero here*/
1736 }
1737 }
1741 {
1751 /* .ctor */
1756 }
1758 }
1760 /*
1761 * mono_class_setup_methods:
1762 * @class: a class
1763 *
1764 * Initializes the 'methods' array in the klass.
1765 * Calling this method should be avoided if possible since it allocates a lot
1766 * of long-living MonoMethod structures.
1767 * Methods belonging to an interface are assigned a sequential slot starting
1768 * from 0.
1769 *
1770 * On failure this function sets class->exception_type
1771 */
1772 void
1774 {
1786 }
1789 MonoError error;
1796 /*FIXME make exception_data less opaque so it's possible to dup it here*/
1797 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Generic type definition failed to load"));
1800 }
1802 /* The + 1 makes this always non-NULL to pass the check in mono_class_setup_methods () */
1811 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)));
1817 }
1818 }
1820 MonoError error;
1835 }
1858 }
1859 /* element Get (idx11, [idx2, ...]) */
1868 /* element& Address (idx11, [idx2, ...]) */
1877 /* void Set (idx11, [idx2, ...], element) */
1889 setup_generic_array_ifaces (class, class->interfaces [i], methods, first_generic + i * count_generic);
1893 int idx = mono_metadata_translate_token_index (class->image, MONO_TABLE_METHOD, class->method.first + i + 1);
1895 }
1896 }
1900 /*Only assign slots to virtual methods as interfaces are allowed to have static methods.*/
1904 }
1905 }
1907 /* Needed because of the double-checking locking pattern */
1916 }
1918 /*
1919 * mono_class_get_method_by_index:
1920 *
1921 * Returns class->methods [index], initializing class->methods if neccesary.
1922 *
1923 * LOCKING: Acquires the loader lock.
1924 */
1925 MonoMethod*
1927 {
1928 /* Avoid calling setup_methods () if possible */
1935 /*
1936 * If setup_methods () is called later for this class, no duplicates are created,
1937 * since inflate_generic_method guarantees that only one instance of a method
1938 * is created for each context.
1939 */
1940 /*
1941 mono_class_setup_methods (class);
1942 g_assert (m == class->methods [index]);
1943 */
1951 }
1952 }
1954 /*
1955 * mono_class_get_inflated_method:
1956 *
1957 * Given an inflated class CLASS and a method METHOD which should be a method of
1958 * CLASS's generic definition, return the inflated method corresponding to METHOD.
1959 */
1960 MonoMethod*
1962 {
1975 else
1976 return mono_class_inflate_generic_method_full (gklass->methods [i], class, mono_class_get_context (class));
1977 }
1978 }
1981 }
1983 /*
1984 * mono_class_get_vtable_entry:
1985 *
1986 * Returns class->vtable [offset], computing it if neccesary.
1987 * LOCKING: Acquires the loader lock.
1988 */
1989 MonoMethod*
1991 {
1995 /*
1996 * szarrays do not overwrite any methods of Array, so we can avoid
1997 * initializing their vtables in some cases.
1998 */
2002 }
2013 }
2016 }
2018 /*
2019 * mono_class_get_vtable_size:
2020 *
2021 * Return the vtable size for KLASS.
2022 */
2023 int
2025 {
2029 }
2031 /*This method can fail the class.*/
2032 static void
2034 {
2039 guint32 last;
2049 }
2059 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Generic type definition failed to load"));
2062 }
2081 }
2083 int first = mono_metadata_properties_from_typedef (class->image, mono_metadata_token_index (class->type_token) - 1, &last);
2091 }
2092 }
2098 mono_metadata_decode_table_row (class->image, MONO_TABLE_PROPERTY, i, cols, MONO_PROPERTY_SIZE);
2101 properties [i - first].name = mono_metadata_string_heap (class->image, cols [MONO_PROPERTY_NAME]);
2110 /* It seems like the MONO_METHOD_SEMA_METHOD column needs no remapping */
2111 method = mono_get_method (class->image, MONO_TOKEN_METHOD_DEF | cols [MONO_METHOD_SEMA_METHOD], class);
2112 else
2124 }
2125 }
2126 }
2127 }
2128 /*Flush any pending writes as we do double checked locking on class->properties */
2131 /* Leave this assignment as the last op in the function */
2135 }
2139 {
2144 ;
2152 }
2154 /*This method can fail the class.*/
2155 static void
2157 {
2162 guint32 last;
2173 }
2183 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Generic type definition failed to load"));
2186 }
2200 event->add = gevent->add ? mono_class_inflate_generic_method_full (gevent->add, class, context) : NULL;
2201 event->remove = gevent->remove ? mono_class_inflate_generic_method_full (gevent->remove, class, context) : NULL;
2202 event->raise = gevent->raise ? mono_class_inflate_generic_method_full (gevent->raise, class, context) : NULL;
2203 #ifndef MONO_SMALL_CONFIG
2205 #endif
2207 }
2211 }
2213 first = mono_metadata_events_from_typedef (class->image, mono_metadata_token_index (class->type_token) - 1, &last);
2219 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Generic type definition failed to load"));
2222 }
2223 }
2242 /* It seems like the MONO_METHOD_SEMA_METHOD column needs no remapping */
2243 method = mono_get_method (class->image, MONO_TOKEN_METHOD_DEF | cols [MONO_METHOD_SEMA_METHOD], class);
2244 else
2258 #ifndef MONO_SMALL_CONFIG
2265 n++;
2267 }
2269 /* NULL terminated */
2271 #endif
2273 }
2276 }
2277 }
2278 }
2279 /*Flush any pending writes as we do double checked locking on class->properties */
2282 /* Leave this assignment as the last op in the function */
2286 }
2288 /*
2289 * Global pool of interface IDs, represented as a bitset.
2290 * LOCKING: this is supposed to be accessed with the loader lock held.
2291 */
2294 /*
2295 * mono_unload_interface_ids:
2296 * @bitset: bit set of interface IDs
2297 *
2298 * When an image is unloaded, the interface IDs associated with
2299 * the image are put back in the global pool of IDs so the numbers
2300 * can be reused.
2301 */
2302 void
2304 {
2308 }
2310 /*
2311 * mono_get_unique_iid:
2312 * @class: interface
2313 *
2314 * Assign a unique integer ID to the interface represented by @class.
2315 * The ID will positive and as small as possible.
2316 * LOCKING: this is supposed to be called with the loader lock held.
2317 * Returns: the new ID.
2318 */
2319 static guint
2321 {
2328 }
2337 }
2339 /* set the bit also in the per-image set */
2345 }
2348 }
2351 #ifndef MONO_SMALL_CONFIG
2360 }
2361 printf ("Interface: assigned id %d to %s|%s|%d\n", iid, class->image->name, type_name, generic_id);
2363 }
2364 #endif
2368 }
2370 static void
2372 {
2391 }
2392 }
2394 GPtrArray*
2396 {
2404 }
2406 }
2408 static int
2414 }
2416 /*FIXME verify all callers if they should switch to mono_class_interface_offset_with_variance*/
2417 int
2420 itf,
2424 compare_interface_ids);
2429 }
2430 }
2432 /*
2433 * mono_class_interface_offset_with_variance:
2434 *
2435 * Return the interface offset of @itf in @klass. Sets @non_exact_match to TRUE if the match required variance check
2436 * If @itf is an interface with generic variant arguments, try to find the compatible one.
2437 *
2438 * Note that this function is responsible for resolving ambiguities. Right now we use whatever ordering interfaces_packed gives us.
2439 *
2440 * FIXME figure out MS disambiguation rules and fix this function.
2441 */
2442 int
2443 mono_class_interface_offset_with_variance (MonoClass *klass, MonoClass *itf, gboolean *non_exact_match) {
2456 }
2457 }
2460 }
2462 static void
2465 MonoError error;
2471 printf ("Packed interface table for class %s has size %d\n", name, klass->interface_offsets_count);
2485 else
2489 #ifdef COMPRESSED_INTERFACE_BITMAP
2490 {
2497 }
2498 }
2499 #else
2500 for (i = 0; i < ((((klass->max_interface_id + 1) >> 3)) + (((klass->max_interface_id + 1) & 7)? 1 :0)); i++)
2502 #endif
2520 }
2522 }
2523 ancestor_level ++;
2525 }
2526 }
2530 {
2535 }
2539 {
2541 }
2543 static void
2545 {
2565 }
2567 /* this won't be needed once bug #325495 is completely fixed
2568 * though we'll need something similar to know which interfaces to allow
2569 * in arrays when they'll be lazyly created
2570 *
2571 * FIXME: System.Array/InternalEnumerator don't need all this interface fabrication machinery.
2572 * MS returns diferrent types based on which instance is called. For example:
2573 * object obj = new byte[10][];
2574 * Type a = ((IEnumerable<byte[]>)obj).GetEnumerator ().GetType ();
2575 * Type b = ((IEnumerable<IList<byte>>)obj).GetEnumerator ().GetType ();
2576 * a != b ==> true
2577 *
2578 * Fixing this should kill quite some code, save some bits and improve compatibility.
2579 */
2582 {
2591 gboolean internal_enumerator;
2592 gboolean eclass_is_valuetype;
2597 }
2602 if (class->generic_class && class->nested_in == mono_defaults.array_class && strcmp (class->name, "InternalEnumerator`1") == 0) {
2603 /*
2604 * For a Enumerator<T[]> we need to get the list of interfaces for T.
2605 */
2614 }
2615 }
2617 /*
2618 * with this non-lazy impl we can't implement all the interfaces so we do just the minimal stuff
2619 * for deep levels of arrays of arrays (string[][] has all the interfaces, string[][][] doesn't)
2620 */
2630 }
2634 /*
2635 * Arrays in 2.0 need to implement a number of generic interfaces
2636 * (IList`1, ICollection`1, IEnumerable`1 for a number of types depending
2637 * on the element class). We collect the types needed to build the
2638 * instantiations in interfaces at intervals of 3, because 3 are
2639 * the generic interfaces needed to implement.
2640 */
2644 /* IList, ICollection, IEnumerable */
2650 }
2662 idepth--;
2664 // FIXME: This doesn't seem to work/required for generic params
2665 if (!(eclass->this_arg.type == MONO_TYPE_VAR || eclass->this_arg.type == MONO_TYPE_MVAR || (eclass->image->dynamic && !eclass->wastypebuilder)))
2669 /* we add object for interfaces and the supertypes for the other
2670 * types. The last of the supertypes is the element class itself which we
2671 * already created the explicit interfaces for (so we include it for IEnumerator
2672 * and exclude it for arrays).
2673 */
2675 interface_count++;
2676 else
2682 }
2683 /* IList, ICollection, IEnumerable */
2687 real_count += (MONO_CLASS_IS_INTERFACE (eclass) ? 1 : idepth) + eclass->interface_offsets_count;
2690 }
2701 }
2702 }
2707 }
2712 }
2713 }
2717 }
2718 }
2720 /* instantiate the generic interfaces */
2727 }
2730 /* instantiate IEnumerator<iface> */
2733 }
2737 interfaces [j] = inflate_class_one_arg (generic_ienumerator_class, mono_defaults.object_class);
2738 j ++;
2742 j ++;
2743 }
2744 }
2746 interfaces [j] = inflate_class_one_arg (generic_ienumerator_class, eclass->interfaces_packed [i]);
2747 j ++;
2748 }
2750 interfaces [j++] = inflate_class_one_arg (generic_ienumerator_class, array_class_get_if_rank (valuetype_types [0], original_rank));
2751 }
2753 interfaces [j] = inflate_class_one_arg (generic_ienumerator_class, array_class_get_if_rank (valuetype_types [1], original_rank));
2754 }
2755 #if 0
2756 {
2762 }
2764 }
2765 #endif
2768 }
2770 static int
2772 {
2777 }
2779 }
2781 /*
2782 * Return the number of virtual methods.
2783 * Even for interfaces we can't simply return the number of methods as all CLR types are allowed to have static methods.
2784 * Return -1 on failure.
2785 * FIXME It would be nice if this information could be cached somewhere.
2786 */
2787 static int
2789 {
2791 guint32 flags;
2792 class = mono_class_get_generic_type_definition (class); /*We can find this information by looking at the GTD*/
2803 }
2806 flags = mono_metadata_decode_table_row_col (class->image, MONO_TABLE_METHOD, class->method.first + i, MONO_METHOD_FLAGS);
2810 }
2811 }
2813 }
2815 static int
2817 {
2833 }
2834 }
2835 }
2837 static int
2838 find_interface_offset (int num_ifaces, MonoClass **interfaces_full, int *interface_offsets_full, MonoClass *ic)
2839 {
2844 }
2846 static mono_bool
2847 set_interface_and_offset (int num_ifaces, MonoClass **interfaces_full, int *interface_offsets_full, MonoClass *ic, int offset, mono_bool force_set)
2848 {
2855 }
2864 memmove (interface_offsets_full + i + 1, interface_offsets_full + i, sizeof (int) * (end - i));
2865 }
2869 }
2871 }
2873 #ifdef COMPRESSED_INTERFACE_BITMAP
2875 /*
2876 * Compressed interface bitmap design.
2877 *
2878 * Interface bitmaps take a large amount of memory, because their size is
2879 * linear with the maximum interface id assigned in the process (each interface
2880 * is assigned a unique id as it is loaded). The number of interface classes
2881 * is high because of the many implicit interfaces implemented by arrays (we'll
2882 * need to lazy-load them in the future).
2883 * Most classes implement a very small number of interfaces, so the bitmap is
2884 * sparse. This bitmap needs to be checked by interface casts, so access to the
2885 * needed bit must be fast and doable with few jit instructions.
2886 *
2887 * The current compression format is as follows:
2888 * *) it is a sequence of one or more two-byte elements
2889 * *) the first byte in the element is the count of empty bitmap bytes
2890 * at the current bitmap position
2891 * *) the second byte in the element is an actual bitmap byte at the current
2892 * bitmap position
2893 *
2894 * As an example, the following compressed bitmap bytes:
2895 * 0x07 0x01 0x00 0x7
2896 * correspond to the following bitmap:
2897 * 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x01 0x07
2898 *
2899 * Each two-byte element can represent up to 2048 bitmap bits, but as few as a single
2900 * bitmap byte for non-sparse sequences. In practice the interface bitmaps created
2901 * during a gmcs bootstrap are reduced to less tha 5% of the original size.
2902 */
2904 /**
2905 * mono_compress_bitmap:
2906 * @dest: destination buffer
2907 * @bitmap: bitmap buffer
2908 * @size: size of @bitmap in bytes
2909 *
2910 * This is a mono internal function.
2911 * The @bitmap data is compressed into a format that is small but
2912 * still searchable in few instructions by the JIT and runtime.
2913 * The compressed data is stored in the buffer pointed to by the
2914 * @dest array. Passing a #NULL value for @dest allows to just compute
2915 * the size of the buffer.
2916 * This compression algorithm assumes the bits set in the bitmap are
2917 * few and far between, like in interface bitmaps.
2918 * Returns: the size of the compressed bitmap in bytes.
2919 */
2920 int
2922 {
2931 }
2934 bitmap++;
2936 }
2937 bitmap++;
2938 numz++;
2939 }
2945 }
2946 }
2948 }
2950 /**
2951 * mono_class_interface_match:
2952 * @bitmap: a compressed bitmap buffer
2953 * @id: the index to check in the bitmap
2954 *
2955 * This is a mono internal function.
2956 * Checks if a bit is set in a compressed interface bitmap. @id must
2957 * be already checked for being smaller than the maximum id encoded in the
2958 * bitmap.
2959 *
2960 * Returns: a non-zero value if bit @id is set in the bitmap @bitmap,
2961 * #FALSE otherwise.
2962 */
2963 int
2965 {
2972 }
2975 }
2976 }
2977 #endif
2979 /*
2980 * LOCKING: this is supposed to be called with the loader lock held.
2981 * Return -1 on failure and set exception_type
2982 */
2983 static int
2985 {
2986 MonoError error;
2999 /*
3000 * get the implicit generic interfaces for either the arrays or for System.Array/InternalEnumerator<T>
3001 * implicit interfaces have the property that they are assigned the same slot in the
3002 * vtables for compatible interfaces
3003 */
3004 array_interfaces = get_implicit_generic_array_interfaces (class, &num_array_interfaces, &is_enumerator);
3006 /* compute maximum number of slots and maximum interface id */
3021 }
3025 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)));
3030 }
3037 }
3039 }
3040 }
3047 }
3050 num_ifaces++;
3053 }
3055 /* compute vtable offset for interfaces */
3061 }
3063 /* skip the current class */
3073 /*Force the sharing of interface offsets between parent and subtypes.*/
3077 }
3078 }
3079 }
3087 if (set_interface_and_offset (num_ifaces, interfaces_full, interface_offsets_full, ic, cur_slot, FALSE))
3092 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Error calculating interface offset of %s", name));
3096 }
3098 }
3099 }
3102 set_interface_and_offset (num_ifaces, interfaces_full, interface_offsets_full, class, cur_slot, TRUE);
3107 int ienumerator_offset = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, class->interfaces [ienumerator_idx]);
3112 set_interface_and_offset (num_ifaces, interfaces_full, interface_offsets_full, ic, ienumerator_offset, TRUE);
3113 else
3115 /*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);*/
3116 }
3123 ilist_offset = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, class->interfaces [ilist_iface_idx]);
3124 icollection_offset = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, ilist_class->interfaces [icollection_iface_idx]);
3125 ienumerable_offset = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, ilist_class->interfaces [ienumerable_iface_idx]);
3136 else
3138 set_interface_and_offset (num_ifaces, interfaces_full, interface_offsets_full, ic, offset, TRUE);
3139 /*g_print ("type %s has %s offset at %d (%s)\n", class->name, ic->name, offset, class->interfaces [0]->name);*/
3140 }
3141 }
3142 }
3146 interface_offsets_count ++;
3147 }
3148 }
3150 /*
3151 * We might get called twice: once from mono_class_init () then once from
3152 * mono_class_setup_vtable ().
3153 */
3160 class->interfaces_packed = mono_image_alloc (class->image, sizeof (MonoClass*) * interface_offsets_count);
3161 class->interface_offsets_packed = mono_image_alloc (class->image, sizeof (guint16) * interface_offsets_count);
3163 #ifdef COMPRESSED_INTERFACE_BITMAP
3165 #else
3167 #endif
3173 /*if (num_array_interfaces)
3174 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]);*/
3175 }
3176 #ifdef COMPRESSED_INTERFACE_BITMAP
3181 #else
3183 #endif
3184 }
3186 end:
3194 }
3197 //printf ("JUST DONE: ");
3198 //print_implemented_interfaces (class);
3201 }
3203 /*
3204 * Setup interface offsets for interfaces.
3205 * Initializes:
3206 * - class->max_interface_id
3207 * - class->interface_offsets_count
3208 * - class->interfaces_packed
3209 * - class->interface_offsets_packed
3210 * - class->interface_bitmap
3211 *
3212 * This function can fail @class.
3213 */
3214 void
3216 {
3222 }
3224 /*
3225 * mono_class_setup_vtable:
3226 *
3227 * Creates the generic vtable of CLASS.
3228 * Initializes the following fields in MonoClass:
3229 * - vtable
3230 * - vtable_size
3231 * Plus all the fields initialized by setup_interface_offsets ().
3232 * If there is an error during vtable construction, class->exception_type is set.
3233 *
3234 * LOCKING: Acquires the loader lock.
3235 */
3236 void
3238 {
3241 guint32 type_token;
3249 /* The debugger currently depends on this */
3253 /* This sets method->slot for all methods if this is an interface */
3256 }
3266 }
3276 }
3279 /* Generic instances can have zero method overrides without causing any harm.
3280 * This is true since we don't do layout all over again for them, we simply inflate
3281 * the layout of the parent.
3282 */
3285 /* The following call fails if there are missing methods in the type */
3286 /* FIXME it's probably a good idea to avoid this for generic instances. */
3288 }
3298 }
3300 #define DEBUG_INTERFACE_VTABLE_CODE 0
3301 #define TRACE_INTERFACE_VTABLE_CODE 0
3302 #define VERIFY_INTERFACE_VTABLE_CODE 0
3303 #define VTABLE_SELECTOR (1)
3305 #if (TRACE_INTERFACE_VTABLE_CODE|DEBUG_INTERFACE_VTABLE_CODE)
3306 #define DEBUG_INTERFACE_VTABLE(stmt) do {\
3307 if (!(VTABLE_SELECTOR)) break; \
3308 stmt;\
3309 } while (0)
3310 #else
3311 #define DEBUG_INTERFACE_VTABLE(stmt)
3312 #endif
3314 #if TRACE_INTERFACE_VTABLE_CODE
3315 #define TRACE_INTERFACE_VTABLE(stmt) do {\
3316 if (!(VTABLE_SELECTOR)) break; \
3317 stmt;\
3318 } while (0)
3319 #else
3320 #define TRACE_INTERFACE_VTABLE(stmt)
3321 #endif
3323 #if VERIFY_INTERFACE_VTABLE_CODE
3324 #define VERIFY_INTERFACE_VTABLE(stmt) do {\
3325 if (!(VTABLE_SELECTOR)) break; \
3326 stmt;\
3327 } while (0)
3328 #else
3329 #define VERIFY_INTERFACE_VTABLE(stmt)
3330 #endif
3333 #if (TRACE_INTERFACE_VTABLE_CODE|DEBUG_INTERFACE_VTABLE_CODE)
3336 {
3346 }
3352 }
3356 }
3357 static void
3365 }
3367 #endif
3368 static gboolean
3369 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) {
3375 }
3381 }
3385 }
3388 }
3389 }
3393 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Could not resolve the signature of a virtual method"));
3395 }
3402 }
3404 /* CAS - SecurityAction.InheritanceDemand on interface */
3407 }
3422 }
3426 }
3427 if (! mono_metadata_signature_equal (mono_method_signature (cm), mono_method_signature (im))) {
3432 }
3436 }
3440 }
3441 if ((ic_name == NULL) || ((strcmp (ic_name, "IEnumerable`1") != 0) && (strcmp (ic_name, "ICollection`1") != 0) && (strcmp (ic_name, "IList`1") != 0))) {
3444 }
3450 }
3455 }
3456 subname ++;
3460 }
3465 }
3466 subname ++;
3470 }
3473 /* CAS - SecurityAction.InheritanceDemand on interface */
3476 }
3483 }
3484 }
3486 #if (TRACE_INTERFACE_VTABLE_CODE|DEBUG_INTERFACE_VTABLE_CODE)
3487 static void
3495 mono_class_get_namespace (method_class), mono_class_get_name (method_class), mono_method_get_name (method),
3496 mono_class_get_namespace (override_class), mono_class_get_name (override_class), mono_method_get_name (override));
3497 }
3498 static void
3506 }
3507 }
3508 static void
3509 print_vtable_full (MonoClass *class, MonoMethod** vtable, int size, int first_non_interface_slot, const char *message, gboolean print_interfaces) {
3519 }
3525 }
3533 }
3534 }
3537 }
3538 #endif
3540 #if VERIFY_INTERFACE_VTABLE_CODE
3541 static int
3543 {
3548 }
3550 }
3552 static void
3554 {
3578 printf ("\tInvalid method %s at index %d with vtable of length %d\n", full_name, slot, class->vtable_size);
3580 }
3583 char *other_name = class->vtable [slot] ? mono_method_full_name (class->vtable [slot], TRUE) : g_strdup ("[null value]");
3586 }
3589 }
3591 }
3592 #endif
3594 static void
3595 print_unimplemented_interface_method_info (MonoClass *class, MonoClass *ic, MonoMethod *im, int im_slot, MonoMethod **overrides, int onum) {
3603 }
3616 }
3623 }
3624 }
3626 static gboolean
3628 {
3635 if (mono_class_get_generic_type_definition (body->klass) != mono_class_get_generic_type_definition (class)) {
3636 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Method belongs to a different class than the declared one"));
3638 }
3642 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Method must not be static to override a base type"));
3643 else
3644 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Method must be virtual to override a base type"));
3646 }
3650 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Cannot override a static method in a base type"));
3651 else
3652 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Cannot override a non virtual method in a base type"));
3654 }
3657 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Method overrides a class or interface that extended or implemented by this type"));
3659 }
3660 }
3662 }
3663 /*
3664 * LOCKING: this is supposed to be called with the loader lock held.
3665 */
3666 void
3668 {
3669 MonoError error;
3677 gpointer class_iter;
3678 #if (DEBUG_INTERFACE_VTABLE_CODE|TRACE_INTERFACE_VTABLE_CODE)
3680 #endif
3692 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)));
3700 }
3703 }
3711 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Parent %s failed to load", name));
3714 }
3718 }
3725 /* printf ("METAINIT %s.%s\n", class->name_space, class->name); */
3734 /* Optimized version for generic instances */
3736 MonoError error;
3744 }
3750 MonoMethod *inflated = mono_class_inflate_generic_method_full_checked (gklass->vtable [i], class, mono_class_get_context (class), &error);
3752 char *err_msg = g_strdup_printf ("Could not inflate method due to %s", mono_error_get_message (&error));
3757 }
3760 }
3764 /* Have to set method->slot for abstract virtual methods */
3769 }
3772 }
3780 // Also inherit parent interface vtables, just as a starting point.
3781 // This is needed otherwise bug-77127.exe fails when the property methods
3782 // have different names in the iterface and the class, because for child
3783 // classes the ".override" information is not used anymore.
3787 /*FIXME this is now dead code as this condition will never hold true.
3788 Since interface offsets are inherited then the offset of an interface implemented
3789 by a parent will never be the out of it's vtable boundary.
3790 */
3796 TRACE_INTERFACE_VTABLE (printf (" +++ Inheriting interface %s.%s\n", parent_interface->name_space, parent_interface->name));
3799 TRACE_INTERFACE_VTABLE (printf (" --- Inheriting: [%03d][(%03d)+(%03d)] => [%03d][(%03d)+(%03d)]\n",
3802 }
3803 }
3805 }
3806 }
3808 TRACE_INTERFACE_VTABLE (print_vtable_full (class, vtable, cur_slot, first_non_interface_slot, "AFTER INHERITING PARENT VTABLE", TRUE));
3809 /* override interface methods */
3818 }
3830 }
3831 }
3833 TRACE_INTERFACE_VTABLE (print_vtable_full (class, vtable, cur_slot, first_non_interface_slot, "AFTER OVERRIDING INTERFACE METHODS", FALSE));
3835 /*
3836 * Create a list of virtual methods to avoid calling
3837 * mono_class_get_virtual_methods () which is slow because of the metadata
3838 * optimization.
3839 */
3840 {
3847 }
3850 }
3852 // Loop on all implemented interfaces...
3856 gboolean interface_is_explicitly_implemented_by_class;
3866 // Check if this interface is explicitly implemented (instead of just inherited)
3870 for (implemented_interfaces_index = 0; implemented_interfaces_index < class->interface_count; implemented_interfaces_index++) {
3874 }
3875 }
3878 }
3880 // Loop on all interface methods...
3884 MonoMethod *override_im = (override_map != NULL) ? g_hash_table_lookup (override_map, im) : NULL;
3889 // If there is an explicit implementation, just use it right away,
3890 // otherwise look for a matching method
3893 gpointer iter;
3896 // First look for a suitable method among the class methods
3900 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)));
3901 if (check_interface_method_override (class, im, cm, TRUE, interface_is_explicitly_implemented_by_class, (vtable [im_slot] == NULL), security_enabled)) {
3904 /* Why do we need this? */
3907 }
3908 }
3912 }
3914 // If the slot is still empty, look in all the inherited virtual methods...
3917 // Reverse order, so that last added methods are preferred
3921 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));
3922 if ((cm != NULL) && check_interface_method_override (class, im, cm, FALSE, FALSE, TRUE, security_enabled)) {
3925 /* Why do we need this? */
3928 }
3930 }
3934 }
3935 }
3938 }
3939 }
3940 }
3942 // If the class is not abstract, check that all its interface slots are full.
3943 // The check is done here and not directly at the end of the loop above because
3944 // it can happen (for injected generic array interfaces) that the same slot is
3945 // processed multiple times (those interfaces have overlapping slots), and it
3946 // will not always be the first pass the one that fills the slot.
3962 TRACE_INTERFACE_VTABLE (printf (" [class is not abstract, checking slot %d for interface '%s'.'%s', method %s, slot check is %d]\n",
3967 }
3968 }
3969 }
3970 }
3972 TRACE_INTERFACE_VTABLE (print_vtable_full (class, vtable, cur_slot, first_non_interface_slot, "AFTER SETTING UP INTERFACE METHODS", FALSE));
3976 /*
3977 * If the method is REUSE_SLOT, we must check in the
3978 * base class for a method to override.
3979 */
3983 gpointer k_iter;
3996 }
4001 /* CAS - SecurityAction.InheritanceDemand */
4004 }
4018 }
4019 }
4025 }
4028 }
4030 /*Non final newslot methods must be given a non-interface vtable slot*/
4031 if ((cm->flags & METHOD_ATTRIBUTE_NEW_SLOT) && !(cm->flags & METHOD_ATTRIBUTE_FINAL) && cm->slot >= 0)
4039 }
4041 /* override non interface methods */
4054 }
4055 }
4057 /*
4058 * If a method occupies more than one place in the vtable, and it is
4059 * overriden, then change the other occurances too.
4060 */
4067 }
4071 }
4076 /* Ensure that all vtable slots are filled with concrete instance methods */
4079 if (vtable [i] == NULL || (vtable [i]->flags & (METHOD_ATTRIBUTE_ABSTRACT | METHOD_ATTRIBUTE_STATIC))) {
4082 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));
4086 }
4087 }
4088 }
4097 /* Check that the vtable_size value computed in mono_class_init () is correct */
4101 }
4103 /* Try to share the vtable with our parent. */
4104 if (class->parent && (class->parent->vtable_size == class->vtable_size) && (memcmp (class->parent->vtable, vtable, sizeof (gpointer) * class->vtable_size) == 0)) {
4112 }
4114 DEBUG_INTERFACE_VTABLE (print_vtable_full (class, class->vtable, class->vtable_size, first_non_interface_slot, "FINALLY", FALSE));
4122 icount++;
4124 printf ("VTable %s (vtable entries = %d, interfaces = %d)\n", mono_type_full_name (&class->byval_arg),
4134 }
4135 }
4147 }
4155 }
4156 }
4157 }
4158 }
4163 fail:
4164 {
4166 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("VTable setup of type %s failed", name));
4172 }
4173 }
4175 /*
4176 * mono_method_get_vtable_slot:
4177 *
4178 * Returns method->slot, computing it if neccesary. Return -1 on failure.
4179 * LOCKING: Acquires the loader lock.
4180 *
4181 * FIXME Use proper MonoError machinery here.
4182 */
4183 int
4185 {
4191 }
4193 }
4195 /**
4196 * mono_method_get_vtable_index:
4197 * @method: a method
4198 *
4199 * Returns the index into the runtime vtable to access the method or,
4200 * in the case of a virtual generic method, the virtual generic method
4201 * thunk. Returns -1 on failure.
4202 *
4203 * FIXME Use proper MonoError machinery here.
4204 */
4205 int
4207 {
4212 }
4214 }
4221 static void
4223 {
4236 }
4243 }
4244 }
4254 static int
4256 {
4266 count_generic++;
4268 }
4269 }
4289 }
4295 i++;
4296 }
4297 /*g_print ("array generic methods: %d\n", count_generic);*/
4302 }
4304 static void
4306 {
4307 MonoGenericContext tmp_context;
4312 //g_print ("setting up array interface: %s\n", mono_type_get_name_full (&iface->byval_arg, 0));
4319 methods [pos++] = mono_marshal_get_generic_array_helper (class, iface, generic_array_method_info [i].name, inflated);
4320 }
4321 }
4325 {
4334 }
4336 static void
4338 {
4343 exception_data = concat_two_strings_with_zero (class->image, error->class_name, error->assembly_name);
4347 exception_data = concat_two_strings_with_zero (class->image, error->class_name, error->member_name);
4356 else
4364 }
4370 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.";
4371 else
4376 }
4384 }
4387 }
4389 /**
4390 * mono_class_init:
4391 * @class: the class to initialize
4392 *
4393 * Compute the instance_size, class_size and other infos that cannot be
4394 * computed at mono_class_get() time. Also compute vtable_size if possible.
4395 * Returns TRUE on success or FALSE if there was a problem in loading
4396 * the type (incorrect assemblies, missing assemblies, methods, etc).
4397 *
4398 * LOCKING: Acquires the loader lock.
4399 */
4400 gboolean
4402 {
4404 MonoCachedClassInfo cached_info;
4405 gboolean has_cached_info;
4409 /* Double-checking locking pattern */
4413 /*g_print ("Init class %s\n", class->name);*/
4415 /* We do everything inside the lock to prevent races */
4420 /* Somebody might have gotten in before us */
4422 }
4426 /* this indicates a cyclic dependency */
4428 }
4433 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, concat_two_strings_with_zero (class->image, class->name, class->image->assembly_name));
4435 }
4445 }
4446 }
4448 /* CAS - SecurityAction.InheritanceDemand */
4449 if (mono_is_security_manager_active () && class->parent && (class->parent->flags & TYPE_ATTRIBUTE_HAS_SECURITY)) {
4451 }
4464 // FIXME: Why is this needed ?
4468 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Generic Type Defintion failed to init"));
4470 }
4474 }
4481 if (class->generic_class || class->image->dynamic || !class->type_token || (has_cached_info && !cached_info.has_nested_classes))
4484 /*
4485 * Computes the size used by the fields, and their locations
4486 */
4496 }
4497 else
4502 }
4504 /* Initialize arrays */
4511 }
4512 }
4519 /*
4520 * Initialize the rest of the data without creating a generic vtable if possible.
4521 * If possible, also compute vtable_size, so mono_class_create_runtime_vtable () can
4522 * also avoid computing a generic vtable.
4523 */
4525 /* AOT case */
4533 /* SZARRAY case */
4539 }
4543 /* Generic instance case */
4552 }
4556 /* General case */
4558 /* ghcimpl is not currently used
4559 class->ghcimpl = 1;
4560 if (class->parent) {
4561 MonoMethod *cmethod = class->vtable [ghc_slot];
4562 if (cmethod->is_inflated)
4563 cmethod = ((MonoMethodInflated*)cmethod)->declaring;
4564 if (cmethod == default_ghc) {
4565 class->ghcimpl = 0;
4566 }
4567 }
4568 */
4570 /* Interfaces and valuetypes are not supposed to have finalizers */
4580 /* FIXME: Optimize this */
4585 }
4588 /* Check that this is really the finalizer method */
4603 }
4604 }
4605 }
4606 }
4607 }
4609 /* C# doesn't allow interfaces to have cctors */
4615 /* The find_method function ignores the 'flags' argument */
4629 }
4630 }
4631 }
4632 }
4633 }
4636 /* This will compute class->parent->vtable_size for some classes */
4641 }
4645 /* FIXME: Get rid of this somehow */
4650 }
4653 }
4657 }
4665 }
4667 }
4671 leave:
4672 /* Because of the double-checking locking pattern */
4683 }
4685 static gboolean
4687 {
4688 /* FIXME: allow the dynamic case for our compilers and with full trust */
4691 else
4693 }
4695 /*
4696 * LOCKING: this assumes the loader lock is held
4697 */
4698 void
4700 {
4713 /*
4714 * do not set the valuetype bit for System.ValueType.
4715 * class->valuetype = 1;
4716 */
4719 /*
4720 * do not set the valuetype bit for System.Enum.
4721 * class->valuetype = 1;
4722 */
4731 }
4732 }
4745 }
4750 }
4756 }
4771 }
4780 }
4795 }
4801 }
4806 }
4810 }
4811 }
4813 }
4818 }
4820 /*
4821 * COM initialization (using mono_init_com_types) is delayed until needed.
4822 * However when a [ComImport] attribute is present on a type it will trigger
4823 * the initialization. This is not a problem unless the BCL being executed
4824 * lacks the types that COM depends on (e.g. Variant on Silverlight).
4825 */
4826 static void
4828 {
4829 /* we don't always allow COM initialization under the CoreCLR (e.g. Moonlight does not require it) */
4831 /* but some other CoreCLR user could requires it for their platform (i.e. trusted) code */
4833 /* but it can not be made available for application (i.e. user code) since all COM calls
4834 * are considered native calls. In this case we fail with a TypeLoadException (just like
4835 * Silverlight 2 does */
4838 }
4839 }
4840 /* FIXME : we should add an extra checks to ensure COM can be initialized properly before continuing */
4842 }
4844 /*
4845 * LOCKING: this assumes the loader lock is held
4846 */
4847 void
4849 {
4850 gboolean system_namespace;
4855 /* if root of the hierarchy */
4860 }
4865 }
4868 /* Imported COM Objects always derive from __ComObject. */
4873 }
4875 /* set the parent to something useful and safe, but mark the type as broken */
4878 }
4883 /*
4884 * If the parent is a generic instance, we may get
4885 * called before it is fully initialized, especially
4886 * before it has its name.
4887 */
4889 }
4896 else
4908 }
4910 if (class->parent->enumtype || (is_corlib_image (class->parent->image) && (strcmp (class->parent->name, "ValueType") == 0) &&
4913 if (is_corlib_image (class->parent->image) && ((strcmp (class->parent->name, "Enum") == 0) && (strcmp (class->parent->name_space, "System") == 0))) {
4915 }
4916 /*class->enumtype = class->parent->enumtype; */
4919 /* initialize com types if COM interfaces are present */
4923 }
4925 }
4927 /*
4928 * mono_class_setup_supertypes:
4929 * @class: a class
4930 *
4931 * Build the data structure needed to make fast type checks work.
4932 * This currently sets two fields in @class:
4933 * - idepth: distance between @class and System.Object in the type
4934 * hierarchy + 1
4935 * - supertypes: array of classes: each element has a class in the hierarchy
4936 * starting from @class up to System.Object
4937 *
4938 * LOCKING: this assumes the loader lock is held
4939 */
4940 void
4942 {
4952 else
4960 memcpy (class->supertypes, class->parent->supertypes, class->parent->idepth * sizeof (gpointer));
4963 }
4964 }
4966 /**
4967 * mono_class_create_from_typedef:
4968 * @image: image where the token is valid
4969 * @type_token: typedef token
4970 *
4971 * Create the MonoClass* representing the specified type token.
4972 * @type_token must be a TypeDef token.
4973 */
4976 {
4987 guint32 nesting_tokeen;
4994 if ((class = mono_internal_hash_table_lookup (&image->class_cache, GUINT_TO_POINTER (type_token)))) {
4997 }
5019 /*
5020 * Check whether we're a generic type definition.
5021 */
5027 }
5033 /*WARNING: this must satisfy mono_metadata_type_hash*/
5039 }
5047 }
5048 }
5052 /* uses ->valuetype, which is initialized by mono_class_setup_parent above */
5055 /*
5056 * This might access class->byval_arg for recursion generated by generic constraints,
5057 * so it has to come after setup_mono_type ().
5058 */
5066 }
5067 }
5072 #ifdef HOST_WIN32
5075 #endif
5085 }
5090 }
5092 /*g_print ("Load class %s\n", name);*/
5094 /*
5095 * Compute the field and method lists
5096 */
5107 }
5112 else
5117 else
5120 /* reserve space to store vector pointer in arrays */
5124 }
5133 }
5135 }
5137 /*
5138 * If we're a generic type definition, load the constraints.
5139 * We must do this after the class has been constructed to make certain recursive scenarios
5140 * work.
5141 */
5142 if (class->generic_container && !mono_metadata_load_generic_param_constraints_full (image, type_token, class->generic_container)){
5144 char *error = concat_two_strings_with_zero (class->image, class_name, class->image->assembly_name);
5150 }
5152 if (class->image->assembly_name && !strcmp (class->image->assembly_name, "Mono.Simd") && !strcmp (nspace, "Mono.Simd")) {
5154 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");
5155 }
5162 }
5164 /** is klass Nullable<T>? */
5165 gboolean
5167 {
5170 }
5173 /** if klass is T? return T */
5174 MonoClass*
5176 {
5179 }
5181 /*
5182 * Create the `MonoClass' for an instantiation of a generic type.
5183 * We only do this if we actually need it.
5184 */
5185 MonoClass*
5187 {
5194 }
5202 /*
5203 * FIXME: the nested type context should include everything the
5204 * nesting context should have, but it may also have additional
5205 * generic parameters...
5206 */
5209 }
5235 /*
5236 * We're not interested in the nested classes of a generic instance.
5237 * We use the generic type definition to look for nested classes.
5238 */
5241 klass->parent = mono_class_inflate_generic_class (gklass->parent, mono_generic_class_get_context (gclass));
5242 }
5250 }
5258 /*
5259 * For enums, gklass->fields might not been set, but instance_size etc. is
5260 * already set in mono_reflection_create_internal_class (). For non-enums,
5261 * these will be computed normally in mono_class_layout_fields ().
5262 */
5266 }
5267 }
5271 inflated_classes ++;
5277 }
5280 make_generic_param_class (MonoGenericParam *param, MonoImage *image, gboolean is_mvar, MonoGenericParamInfo *pinfo)
5281 {
5287 /* FIXME: */
5299 }
5308 }
5311 }
5318 ;
5323 pos++;
5326 else
5336 }
5348 /* We don't use type_token for VAR since only classes can use it (not arrays, pointer, VARs, etc) */
5351 /*Init these fields to sane values*/
5362 }
5365 }
5367 #define FAST_CACHE_SIZE 16
5375 {
5383 }
5385 static void
5387 {
5394 }
5400 else
5402 }
5405 }
5407 /*
5408 * LOCKING: Acquires the loader lock.
5409 */
5410 MonoClass *
5411 mono_class_from_generic_parameter (MonoGenericParam *param, MonoImage *image, gboolean is_mvar)
5412 {
5424 }
5433 }
5434 }
5442 // FIXME: 'klass' should not be null
5443 // But, monodis creates GenericContainers without associating a owner to it
5445 }
5446 }
5454 else
5459 /* FIXME: Should this go inside 'make_generic_param_klass'? */
5463 }
5465 MonoClass *
5467 {
5484 }
5500 /* Can pointers get boxed? */
5518 }
5522 {
5526 /* FIXME: These should be allocate from a mempool as well, but which one ? */
5536 }
5547 result->flags = TYPE_ATTRIBUTE_CLASS; /* | (el_class->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK); */
5548 /* Can pointers get boxed? */
5567 }
5569 MonoClass *
5571 {
5629 }
5632 }
5634 /**
5635 * mono_type_retrieve_from_typespec
5636 * @image: context where the image is created
5637 * @type_spec: typespec token
5638 * @context: the generic context used to evaluate generic instantiations in
5639 */
5641 mono_type_retrieve_from_typespec (MonoImage *image, guint32 type_spec, MonoGenericContext *context, gboolean *did_inflate, MonoError *error)
5642 {
5651 mono_error_set_type_load_name (error, name, assembly, "Could not resolve typespec token %08x", type_spec);
5653 }
5664 }
5665 }
5667 }
5669 /**
5670 * mono_class_create_from_typespec
5671 * @image: context where the image is created
5672 * @type_spec: typespec token
5673 * @context: the generic context used to evaluate generic instantiations in
5674 */
5676 mono_class_create_from_typespec (MonoImage *image, guint32 type_spec, MonoGenericContext *context, MonoError *error)
5677 {
5687 }
5689 /**
5690 * mono_bounded_array_class_get:
5691 * @element_class: element class
5692 * @rank: the dimension of the array class
5693 * @bounded: whenever the array has non-zero bounds
5694 *
5695 * Returns: a class object describing the array with element type @element_type and
5696 * dimension @rank.
5697 */
5698 MonoClass *
5700 {
5712 /* bounded only matters for one-dimensional arrays */
5718 /*
5719 * This case is very frequent not just during compilation because of calls
5720 * from mono_class_from_mono_type (), mono_array_new (),
5721 * Array:CreateInstance (), etc, so use a separate cache + a separate lock.
5722 */
5741 if ((class->rank == rank) && (class->byval_arg.type == (((rank > 1) || bounded) ? MONO_TYPE_ARRAY : MONO_TYPE_SZARRAY))) {
5744 }
5745 }
5746 }
5747 }
5749 /* for the building corlib use System.Array from it */
5750 if (image->assembly && image->assembly->dynamic && image->assembly_name && strcmp (image->assembly_name, "mscorlib") == 0) {
5757 }
5781 /* all arrays are marked serializable and sealed, bug #42779 */
5782 class->flags = TYPE_ATTRIBUTE_CLASS | TYPE_ATTRIBUTE_SERIALIZABLE | TYPE_ATTRIBUTE_SEALED | TYPE_ATTRIBUTE_PUBLIC;
5790 }
5791 /* element_size -1 is ok as this is not an instantitable type*/
5802 if (eclass->exception_type) /*FIXME we fail the array type, but we have to let other fields be set.*/
5805 class->has_references = MONO_TYPE_IS_REFERENCE (&eclass->byval_arg) || eclass->has_references? TRUE: FALSE;
5811 else
5822 #if SIZEOF_VOID_P == 4
5825 #endif
5829 #if SIZEOF_VOID_P == 8
5832 #endif
5835 }
5845 /* FIXME: complete.... */
5849 }
5854 }
5864 /* Someone got in before us */
5866 else
5872 }
5879 }
5881 /**
5882 * mono_array_class_get:
5883 * @element_class: element class
5884 * @rank: the dimension of the array class
5885 *
5886 * Returns: a class object describing the array with element type @element_type and
5887 * dimension @rank.
5888 */
5889 MonoClass *
5891 {
5893 }
5895 /**
5896 * mono_class_instance_size:
5897 * @klass: a class
5898 *
5899 * Returns: the size of an object instance
5900 */
5901 gint32
5903 {
5908 }
5910 /**
5911 * mono_class_min_align:
5912 * @klass: a class
5913 *
5914 * Returns: minimm alignment requirements
5915 */
5916 gint32
5918 {
5923 }
5925 /**
5926 * mono_class_value_size:
5927 * @klass: a class
5928 *
5929 * This function is used for value types, and return the
5930 * space and the alignment to store that kind of value object.
5931 *
5932 * Returns: the size of a value of kind @klass
5933 */
5934 gint32
5936 {
5937 gint32 size;
5939 /* fixme: check disable, because we still have external revereces to
5940 * mscorlib and Dummy Objects
5941 */
5942 /*g_assert (klass->valuetype);*/
5950 }
5952 /**
5953 * mono_class_data_size:
5954 * @klass: a class
5955 *
5956 * Returns: the size of the static class data
5957 */
5958 gint32
5960 {
5964 /* in arrays, sizes.class_size is unioned with element_size
5965 * and arrays have no static fields
5966 */
5970 }
5972 /*
5973 * Auxiliary routine to mono_class_get_field
5974 *
5975 * Takes a field index instead of a field token.
5976 */
5979 {
5986 /*
5987 * class->field.first points to the FieldPtr table, while idx points into the
5988 * Field table, so we have to do a search.
5989 */
5990 /*FIXME this is broken for types with multiple fields with the same name.*/
5991 const char *name = mono_metadata_string_heap (class->image, mono_metadata_decode_row_col (&class->image->tables [MONO_TABLE_FIELD], idx, MONO_FIELD_NAME));
6002 }
6003 }
6004 }
6006 }
6008 }
6010 /**
6011 * mono_class_get_field:
6012 * @class: the class to lookup the field.
6013 * @field_token: the field token
6014 *
6015 * Returns: A MonoClassField representing the type and offset of
6016 * the field, or a NULL value if the field does not belong to this
6017 * class.
6018 */
6019 MonoClassField *
6021 {
6027 }
6029 /**
6030 * mono_class_get_field_from_name:
6031 * @klass: the class to lookup the field.
6032 * @name: the field name
6033 *
6034 * Search the class @klass and it's parents for a field with the name @name.
6035 *
6036 * Returns: the MonoClassField pointer of the named field or NULL
6037 */
6038 MonoClassField *
6040 {
6042 }
6044 /**
6045 * mono_class_get_field_from_name_full:
6046 * @klass: the class to lookup the field.
6047 * @name: the field name
6048 * @type: the type of the fields. This optional.
6049 *
6050 * Search the class @klass and it's parents for a field with the name @name and type @type.
6051 *
6052 * If @klass is an inflated generic type, the type comparison is done with the equivalent field
6053 * of its generic type definition.
6054 *
6055 * Returns: the MonoClassField pointer of the named field or NULL
6056 */
6057 MonoClassField *
6059 {
6074 MonoType *field_type = mono_metadata_get_corresponding_field_from_generic_type_definition (field)->type;
6077 }
6079 }
6081 }
6083 }
6085 /**
6086 * mono_class_get_field_token:
6087 * @field: the field we need the token of
6088 *
6089 * Get the token of a field. Note that the tokesn is only valid for the image
6090 * the field was loaded from. Don't use this function for fields in dynamic types.
6091 *
6092 * Returns: the token representing the field in the image it was loaded from.
6093 */
6094 guint32
6096 {
6112 }
6113 }
6115 }
6119 }
6121 static int
6123 {
6129 }
6131 /*
6132 * mono_class_get_field_default_value:
6133 *
6134 * Return the default value of the field as a pointer into the metadata blob.
6135 */
6138 {
6139 guint32 cindex;
6150 klass->ext->field_def_values = mono_image_alloc0 (klass->image, sizeof (MonoFieldDefaultValue) * klass->field.count);
6152 }
6157 cindex = mono_metadata_get_constant_index (field->parent->image, mono_class_get_field_token (field), 0);
6161 mono_metadata_decode_row (&field->parent->image->tables [MONO_TABLE_CONSTANT], cindex - 1, constant_cols, MONO_CONSTANT_SIZE);
6163 klass->ext->field_def_values [field_index].data = (gpointer)mono_metadata_blob_heap (field->parent->image, constant_cols [MONO_CONSTANT_VALUE]);
6164 }
6168 }
6170 /*
6171 * mono_class_get_property_default_value:
6172 *
6173 * Return the default value of the field as a pointer into the metadata blob.
6174 */
6177 {
6178 guint32 cindex;
6183 /*We don't cache here because it is not used by C# so it's quite rare.*/
6185 cindex = mono_metadata_get_constant_index (klass->image, mono_class_get_property_token (property), 0);
6189 mono_metadata_decode_row (&klass->image->tables [MONO_TABLE_CONSTANT], cindex - 1, constant_cols, MONO_CONSTANT_SIZE);
6192 }
6194 guint32
6196 {
6205 }
6206 }
6208 }
6212 }
6214 MonoProperty*
6216 {
6223 }
6225 }
6227 }
6229 guint32
6231 {
6241 i ++;
6242 }
6244 }
6248 }
6252 {
6271 else
6273 }
6287 else
6289 }
6295 }
6296 }
6300 {
6309 MonoAssemblyName aname;
6322 /* FIXME: */
6325 /* FIXME: */
6328 /* FIXME: */
6335 }
6337 }
6339 /* FIXME: */
6343 }
6346 }
6348 /**
6349 * mono_class_get_full:
6350 * @image: the image where the class resides
6351 * @type_token: the token for the class
6352 * @context: the generic context used to evaluate generic instantiations in
6353 *
6354 * Returns: the MonoClass that represents @type_token in @image
6355 */
6356 MonoClass *
6358 {
6359 MonoError error;
6365 if (table != MONO_TABLE_TYPEDEF && table != MONO_TABLE_TYPEREF && table != MONO_TABLE_TYPESPEC) {
6368 }
6370 }
6382 /*FIXME don't swallow the error message*/
6384 }
6389 }
6395 }
6398 }
6401 /**
6402 * mono_type_get_full:
6403 * @image: the image where the type resides
6404 * @type_token: the token for the type
6405 * @context: the generic context used to evaluate generic instantiations in
6406 *
6407 * This functions exists to fullfill the fact that sometimes it's desirable to have access to the
6408 *
6409 * Returns: the MonoType that represents @type_token in @image
6410 */
6411 MonoType *
6413 {
6414 MonoError error;
6418 //FIXME: this will not fix the very issue for which mono_type_get_full exists -but how to do it then?
6425 }
6430 /*FIXME don't swalloc the error message.*/
6434 g_warning ("Error loading type %s from %s due to %s", name, assembly, mono_error_get_message (&error));
6439 }
6444 /* FIXME: This is a workaround fo the fact that a typespec token sometimes reference to the generic type definition.
6445 * A MonoClass::byval_arg of a generic type definion has type CLASS.
6446 * Some parts of mono create a GENERICINST to reference a generic type definition and this generates confict with byval_arg.
6447 *
6448 * The long term solution is to chaise this places and make then set MonoType::type correctly.
6449 * */
6452 else
6454 }
6456 }
6459 MonoClass *
6461 {
6463 }
6465 /**
6466 * mono_image_init_name_cache:
6467 *
6468 * Initializes the class name cache stored in image->name_cache.
6469 *
6470 * LOCKING: Acquires the corresponding image lock.
6471 */
6472 void
6474 {
6487 }
6494 }
6496 /* Temporary hash table to avoid lookups in the nspace_table */
6502 /*
6503 * Nested types are accessed from the nesting name. We use the fact that nested types use different visibility flags
6504 * than toplevel types, thus avoiding the need to grovel through the NESTED_TYPE table
6505 */
6517 nspace_table);
6518 }
6520 }
6522 /* Load type names from EXPORTEDTYPES table */
6523 {
6539 nspace_table);
6540 }
6541 g_hash_table_insert (nspace_table, (char *) name, GUINT_TO_POINTER (mono_metadata_make_token (MONO_TABLE_EXPORTEDTYPE, i + 1)));
6542 }
6543 }
6547 }
6549 /*FIXME Only dynamic assemblies should allow this operation.*/
6550 void
6553 {
6556 guint32 old_index;
6567 }
6570 g_error ("overrwritting old token %x on image %s for type %s::%s", old_index, image->name, nspace, name);
6575 }
6578 gconstpointer key;
6579 gpointer value;
6582 static void
6584 {
6590 }
6592 /**
6593 * mono_class_from_name_case:
6594 * @image: The MonoImage where the type is looked up in
6595 * @name_space: the type namespace
6596 * @name: the type short name.
6597 *
6598 * Obtains a MonoClass with a given namespace and a given name which
6599 * is located in the given MonoImage. The namespace and name
6600 * lookups are case insensitive.
6601 */
6602 MonoClass *
6604 {
6613 FindUserData user_data;
6634 }
6640 else
6643 }
6645 /* add a cache if needed */
6649 /*
6650 * Nested types are accessed from the nesting name. We use the fact that nested types use different visibility flags
6651 * than toplevel types, thus avoiding the need to grovel through the NESTED_TYPE table
6652 */
6659 }
6661 }
6665 {
6672 s++;
6673 }
6680 }
6681 }
6683 }
6687 {
6693 /*
6694 * The EXPORTEDTYPES table only contains public types, so have to search the
6695 * modules as well.
6696 * Note: image->modules contains the contents of the MODULEREF table, while
6697 * the real module list is in the FILE table.
6698 */
6710 }
6711 }
6714 }
6716 /**
6717 * mono_class_from_name:
6718 * @image: The MonoImage where the type is looked up in
6719 * @name_space: the type namespace
6720 * @name: the type short name.
6721 *
6722 * Obtains a MonoClass with a given namespace and a given name which
6723 * is located in the given MonoImage.
6724 */
6725 MonoClass *
6727 {
6745 }
6754 else
6756 }
6757 }
6772 /* Search modules as well */
6779 }
6780 }
6786 }
6810 guint32 assembly_idx;
6818 else
6819 /* FIXME: Cycle detection */
6823 }
6824 }
6832 }
6834 /*FIXME test for interfaces with variant generic arguments*/
6835 gboolean
6837 gboolean check_interfaces)
6838 {
6840 if (check_interfaces && MONO_CLASS_IS_INTERFACE (klassc) && !MONO_CLASS_IS_INTERFACE (klass)) {
6843 } else if (check_interfaces && MONO_CLASS_IS_INTERFACE (klassc) && MONO_CLASS_IS_INTERFACE (klass)) {
6850 }
6854 }
6856 /*
6857 * MS.NET thinks interfaces are a subclass of Object, so we think it as
6858 * well.
6859 */
6864 }
6866 gboolean
6868 {
6878 if (mono_generic_container_get_param_info (container, i)->flags & (MONO_GEN_PARAM_VARIANT|MONO_GEN_PARAM_COVARIANT))
6882 }
6884 /**
6885 * @container the generic container from the GTD
6886 * @klass: the class to be assigned to
6887 * @oklass: the source class
6888 *
6889 * Both klass and oklass must be instances of the same generic interface.
6890 * Return true if @klass can be assigned to a @klass variable
6891 */
6892 static gboolean
6894 {
6900 /*Viable candidates are instances of the same generic interface*/
6914 /*
6915 * The _VARIANT and _COVARIANT constants should read _COVARIANT and
6916 * _CONTRAVARIANT, but they are in a public header so we can't fix it.
6917 */
6922 } else if (mono_generic_container_get_param_info (container, j)->flags & MONO_GEN_PARAM_COVARIANT) {
6927 }
6928 }
6930 }
6932 /**
6933 * mono_class_is_assignable_from:
6934 * @klass: the class to be assigned to
6935 * @oklass: the source class
6936 *
6937 * Return: true if an instance of object oklass can be assigned to an
6938 * instance of object @klass
6939 */
6940 gboolean
6942 {
6956 /* interface_offsets might not be set for dynamic classes */
6958 /*
6959 * oklass might be a generic type parameter but they have
6960 * interface_offsets set.
6961 */
6964 /* Happens with generic instances of not-yet created dynamic types */
6970 MonoError error;
6976 }
6978 /*klass is a generic variant interface, We need to extract from oklass a list of ifaces which are viable candidates.*/
6984 }
6985 }
6988 if (mono_class_has_variant_generic_params (klass) && mono_class_is_variant_compatible (klass, oklass))
6996 /* vectors vs. one dimensional arrays */
7003 /*
7004 * a is b does not imply a[] is b[] when a is a valuetype, and
7005 * b is a reference type.
7006 */
7013 }
7019 else
7025 }
7027 /*Check if @oklass is variant compatible with @klass.*/
7028 static gboolean
7030 {
7036 /*Viable candidates are instances of the same generic interface*/
7050 /*
7051 * The _VARIANT and _COVARIANT constants should read _COVARIANT and
7052 * _CONTRAVARIANT, but they are in a public header so we can't fix it.
7053 */
7058 } else if (mono_generic_container_get_param_info (container, j)->flags & MONO_GEN_PARAM_COVARIANT) {
7063 }
7064 }
7066 }
7067 /*Check if @candidate implements the interface @target*/
7068 static gboolean
7070 {
7071 MonoError error;
7078 }
7084 /*A TypeBuilder can have more interfaces on tb->interfaces than on candidate->interfaces*/
7098 }
7099 }
7101 /*setup_interfaces don't mono_class_init anything*/
7106 }
7117 }
7118 }
7123 }
7125 /*
7126 * Check if @oklass can be assigned to @klass.
7127 * This function does the same as mono_class_is_assignable_from but is safe to be used from mono_class_init context.
7128 */
7129 gboolean
7131 {
7137 /*setup_supertypes don't mono_class_init anything */
7144 /*If target is not an interface there is no need to check them.*/
7151 /*FIXME properly handle nullables and arrays */
7154 }
7156 /**
7157 * mono_class_get_cctor:
7158 * @klass: A MonoClass pointer
7159 *
7160 * Returns: the static constructor of @klass if it exists, NULL otherwise.
7161 */
7162 MonoMethod*
7164 {
7165 MonoCachedClassInfo cached_info;
7168 /*
7169 * has_cctor is not set for these classes because mono_class_init () is
7170 * not run for them.
7171 */
7172 return mono_class_get_method_from_name_flags (klass, ".cctor", -1, METHOD_ATTRIBUTE_SPECIAL_NAME);
7173 }
7182 return mono_class_get_inflated_method (klass, mono_class_get_cctor (klass->generic_class->container_class));
7184 return mono_class_get_method_from_name_flags (klass, ".cctor", -1, METHOD_ATTRIBUTE_SPECIAL_NAME);
7185 }
7187 /**
7188 * mono_class_get_finalizer:
7189 * @klass: The MonoClass pointer
7190 *
7191 * Returns: the finalizer method of @klass if it exists, NULL otherwise.
7192 */
7193 MonoMethod*
7195 {
7196 MonoCachedClassInfo cached_info;
7208 }
7209 }
7211 /**
7212 * mono_class_needs_cctor_run:
7213 * @klass: the MonoClass pointer
7214 * @caller: a MonoMethod describing the caller
7215 *
7216 * Determines whenever the class has a static constructor and whenever it
7217 * needs to be called when executing CALLER.
7218 */
7219 gboolean
7221 {
7227 else
7229 }
7231 /**
7232 * mono_class_array_element_size:
7233 * @klass:
7234 *
7235 * Returns: the number of bytes an element of type @klass
7236 * uses when stored into an array.
7237 */
7238 gint32
7240 {
7243 handle_enum:
7277 }
7288 }
7290 }
7292 /**
7293 * mono_array_element_size:
7294 * @ac: pointer to a #MonoArrayClass
7295 *
7296 * Returns: the size of single array element.
7297 */
7298 gint32
7300 {
7303 }
7305 gpointer
7308 {
7311 gpointer obj = mono_lookup_dynamic_token_class (image, token, TRUE, &tmp_handle_class, context);
7319 else
7321 }
7334 /* We return a MonoType* as handle */
7336 }
7349 }
7357 }
7361 mono_metadata_decode_row (&image->tables [MONO_TABLE_MEMBERREF], mono_metadata_token_index (token) - 1, cols, MONO_MEMBERREF_SIZE);
7377 }
7378 }
7382 }
7384 }
7386 /**
7387 * This function might need to call runtime functions so it can't be part
7388 * of the metadata library.
7389 */
7392 void
7394 {
7396 }
7398 gpointer
7400 {
7404 }
7406 gpointer
7407 mono_lookup_dynamic_token_class (MonoImage *image, guint32 token, gboolean valid_token, MonoClass **handle_class, MonoGenericContext *context)
7408 {
7410 }
7414 void
7416 {
7418 }
7420 static gboolean
7422 {
7425 else
7427 }
7429 void
7431 {
7433 }
7435 MonoImage*
7437 {
7439 }
7441 /**
7442 * mono_class_get_element_class:
7443 * @klass: the MonoClass to act on
7444 *
7445 * Returns: the element class of an array or an enumeration.
7446 */
7447 MonoClass*
7449 {
7451 }
7453 /**
7454 * mono_class_is_valuetype:
7455 * @klass: the MonoClass to act on
7456 *
7457 * Returns: true if the MonoClass represents a ValueType.
7458 */
7459 gboolean
7461 {
7463 }
7465 /**
7466 * mono_class_is_enum:
7467 * @klass: the MonoClass to act on
7468 *
7469 * Returns: true if the MonoClass represents an enumeration.
7470 */
7471 gboolean
7473 {
7475 }
7477 /**
7478 * mono_class_enum_basetype:
7479 * @klass: the MonoClass to act on
7480 *
7481 * Returns: the underlying type representation for an enumeration.
7482 */
7483 MonoType*
7485 {
7487 /* SRE or broken types */
7489 else
7491 }
7493 /**
7494 * mono_class_get_parent
7495 * @klass: the MonoClass to act on
7496 *
7497 * Returns: the parent class for this class.
7498 */
7499 MonoClass*
7501 {
7503 }
7505 /**
7506 * mono_class_get_nesting_type;
7507 * @klass: the MonoClass to act on
7508 *
7509 * Returns: the container type where this type is nested or NULL if this type is not a nested type.
7510 */
7511 MonoClass*
7513 {
7515 }
7517 /**
7518 * mono_class_get_rank:
7519 * @klass: the MonoClass to act on
7520 *
7521 * Returns: the rank for the array (the number of dimensions).
7522 */
7523 int
7525 {
7527 }
7529 /**
7530 * mono_class_get_flags:
7531 * @klass: the MonoClass to act on
7532 *
7533 * The type flags from the TypeDef table from the metadata.
7534 * see the TYPE_ATTRIBUTE_* definitions on tabledefs.h for the
7535 * different values.
7536 *
7537 * Returns: the flags from the TypeDef table.
7538 */
7539 guint32
7541 {
7543 }
7545 /**
7546 * mono_class_get_name
7547 * @klass: the MonoClass to act on
7548 *
7549 * Returns: the name of the class.
7550 */
7553 {
7555 }
7557 /**
7558 * mono_class_get_namespace:
7559 * @klass: the MonoClass to act on
7560 *
7561 * Returns: the namespace of the class.
7562 */
7565 {
7567 }
7569 /**
7570 * mono_class_get_type:
7571 * @klass: the MonoClass to act on
7572 *
7573 * This method returns the internal Type representation for the class.
7574 *
7575 * Returns: the MonoType from the class.
7576 */
7577 MonoType*
7579 {
7581 }
7583 /**
7584 * mono_class_get_type_token
7585 * @klass: the MonoClass to act on
7586 *
7587 * This method returns type token for the class.
7588 *
7589 * Returns: the type token for the class.
7590 */
7591 guint32
7593 {
7595 }
7597 /**
7598 * mono_class_get_byref_type:
7599 * @klass: the MonoClass to act on
7600 *
7601 *
7602 */
7603 MonoType*
7605 {
7607 }
7609 /**
7610 * mono_class_num_fields:
7611 * @klass: the MonoClass to act on
7612 *
7613 * Returns: the number of static and instance fields in the class.
7614 */
7615 int
7617 {
7619 }
7621 /**
7622 * mono_class_num_methods:
7623 * @klass: the MonoClass to act on
7624 *
7625 * Returns: the number of methods in the class.
7626 */
7627 int
7629 {
7631 }
7633 /**
7634 * mono_class_num_properties
7635 * @klass: the MonoClass to act on
7636 *
7637 * Returns: the number of properties in the class.
7638 */
7639 int
7641 {
7645 }
7647 /**
7648 * mono_class_num_events:
7649 * @klass: the MonoClass to act on
7650 *
7651 * Returns: the number of events in the class.
7652 */
7653 int
7655 {
7659 }
7661 /**
7662 * mono_class_get_fields:
7663 * @klass: the MonoClass to act on
7664 *
7665 * This routine is an iterator routine for retrieving the fields in a class.
7666 *
7667 * You must pass a gpointer that points to zero and is treated as an opaque handle to
7668 * iterate over all of the elements. When no more values are
7669 * available, the return value is NULL.
7670 *
7671 * Returns: a @MonoClassField* on each iteration, or NULL when no more fields are available.
7672 */
7673 MonoClassField*
7675 {
7683 /* start from the first */
7687 /* no fields */
7689 }
7690 }
7692 field++;
7695 }
7697 }
7699 /**
7700 * mono_class_get_methods
7701 * @klass: the MonoClass to act on
7702 *
7703 * This routine is an iterator routine for retrieving the fields in a class.
7704 *
7705 * You must pass a gpointer that points to zero and is treated as an opaque handle to
7706 * iterate over all of the elements. When no more values are
7707 * available, the return value is NULL.
7708 *
7709 * Returns: a MonoMethod on each iteration or NULL when no more methods are available.
7710 */
7711 MonoMethod*
7713 {
7722 /*
7723 * We can't fail lookup of methods otherwise the runtime will burst in flames on all sort of places.
7724 * FIXME we should better report this error to the caller
7725 */
7728 /* start from the first */
7733 /* no method */
7735 }
7736 }
7738 method++;
7742 }
7744 }
7746 /*
7747 * mono_class_get_virtual_methods:
7748 *
7749 * Iterate over the virtual methods of KLASS.
7750 *
7751 * LOCKING: Assumes the loader lock is held (because of the klass->methods check).
7752 */
7755 {
7759 if (klass->methods || !MONO_CLASS_HAS_STATIC_METADATA (klass) || mono_debug_using_mono_debugger ()) {
7762 /*
7763 * We can't fail lookup of methods otherwise the runtime will burst in flames on all sort of places.
7764 * FIXME we should better report this error to the caller
7765 */
7768 /* start from the first */
7772 method++;
7773 }
7777 method ++;
7778 }
7784 }
7786 /* Search directly in metadata to avoid calling setup_methods () */
7794 }
7797 guint32 flags;
7799 /* class->method.first points into the methodptr table */
7800 flags = mono_metadata_decode_table_row_col (klass->image, MONO_TABLE_METHOD, klass->method.first + i, MONO_METHOD_FLAGS);
7804 }
7807 res = mono_get_method (klass->image, MONO_TOKEN_METHOD_DEF | (klass->method.first + i + 1), klass);
7808 /* Add 1 here so the if (*iter) check fails */
7813 }
7814 }
7815 }
7817 /**
7818 * mono_class_get_properties:
7819 * @klass: the MonoClass to act on
7820 *
7821 * This routine is an iterator routine for retrieving the properties in a class.
7822 *
7823 * You must pass a gpointer that points to zero and is treated as an opaque handle to
7824 * iterate over all of the elements. When no more values are
7825 * available, the return value is NULL.
7826 *
7827 * Returns: a @MonoProperty* on each invocation, or NULL when no more are available.
7828 */
7829 MonoProperty*
7831 {
7839 /* start from the first */
7843 /* no fields */
7845 }
7846 }
7848 property++;
7851 }
7853 }
7855 /**
7856 * mono_class_get_events:
7857 * @klass: the MonoClass to act on
7858 *
7859 * This routine is an iterator routine for retrieving the properties in a class.
7860 *
7861 * You must pass a gpointer that points to zero and is treated as an opaque handle to
7862 * iterate over all of the elements. When no more values are
7863 * available, the return value is NULL.
7864 *
7865 * Returns: a @MonoEvent* on each invocation, or NULL when no more are available.
7866 */
7867 MonoEvent*
7869 {
7877 /* start from the first */
7881 /* no fields */
7883 }
7884 }
7886 event++;
7889 }
7891 }
7893 /**
7894 * mono_class_get_interfaces
7895 * @klass: the MonoClass to act on
7896 *
7897 * This routine is an iterator routine for retrieving the interfaces implemented by this class.
7898 *
7899 * You must pass a gpointer that points to zero and is treated as an opaque handle to
7900 * iterate over all of the elements. When no more values are
7901 * available, the return value is NULL.
7902 *
7903 * Returns: a @Monoclass* on each invocation, or NULL when no more are available.
7904 */
7905 MonoClass*
7907 {
7908 MonoError error;
7920 }
7921 }
7922 /* start from the first */
7927 /* no interface */
7929 }
7930 }
7932 iface++;
7936 }
7938 }
7940 /**
7941 * mono_class_get_nested_types
7942 * @klass: the MonoClass to act on
7943 *
7944 * This routine is an iterator routine for retrieving the nested types of a class.
7945 * This works only if @klass is non-generic, or a generic type definition.
7946 *
7947 * You must pass a gpointer that points to zero and is treated as an opaque handle to
7948 * iterate over all of the elements. When no more values are
7949 * available, the return value is NULL.
7950 *
7951 * Returns: a @Monoclass* on each invocation, or NULL when no more are available.
7952 */
7953 MonoClass*
7955 {
7972 mono_metadata_decode_row (&klass->image->tables [MONO_TABLE_NESTEDCLASS], i - 1, cols, MONO_NESTED_CLASS_SIZE);
7973 nclass = mono_class_create_from_typedef (klass->image, MONO_TOKEN_TYPE_DEF | cols [MONO_NESTED_CLASS_NESTED]);
7977 klass->ext->nested_classes = g_list_prepend_image (klass->image, klass->ext->nested_classes, nclass);
7980 }
7981 }
7985 }
7988 /* start from the first */
7993 /* no nested types */
7995 }
7996 }
8002 }
8004 }
8006 /**
8007 * mono_field_get_name:
8008 * @field: the MonoClassField to act on
8009 *
8010 * Returns: the name of the field.
8011 */
8014 {
8016 }
8018 /**
8019 * mono_field_get_type:
8020 * @field: the MonoClassField to act on
8021 *
8022 * Returns: MonoType of the field.
8023 */
8024 MonoType*
8026 {
8028 }
8030 /**
8031 * mono_field_get_parent:
8032 * @field: the MonoClassField to act on
8033 *
8034 * Returns: MonoClass where the field was defined.
8035 */
8036 MonoClass*
8038 {
8040 }
8042 /**
8043 * mono_field_get_flags;
8044 * @field: the MonoClassField to act on
8045 *
8046 * The metadata flags for a field are encoded using the
8047 * FIELD_ATTRIBUTE_* constants. See the tabledefs.h file for details.
8048 *
8049 * Returns: the flags for the field.
8050 */
8051 guint32
8053 {
8055 }
8057 /**
8058 * mono_field_get_offset;
8059 * @field: the MonoClassField to act on
8060 *
8061 * Returns: the field offset.
8062 */
8063 guint32
8065 {
8067 }
8071 {
8072 guint32 rva;
8082 klass->ext->field_def_values = mono_image_alloc0 (klass->image, sizeof (MonoFieldDefaultValue) * klass->field.count);
8084 }
8089 mono_metadata_field_info (field->parent->image, klass->field.first + field_index, NULL, &rva, NULL);
8091 g_warning ("field %s in %s should have RVA data, but hasn't", mono_field_get_name (field), field->parent->name);
8092 klass->ext->field_def_values [field_index].data = mono_image_rva_map (field->parent->image, rva);
8093 }
8096 }
8098 /**
8099 * mono_field_get_data;
8100 * @field: the MonoClassField to act on
8101 *
8102 * Returns: pointer to the metadata constant value or to the field
8103 * data if it has an RVA flag.
8104 */
8107 {
8109 MonoTypeEnum def_type;
8116 }
8117 }
8119 /**
8120 * mono_property_get_name:
8121 * @prop: the MonoProperty to act on
8122 *
8123 * Returns: the name of the property
8124 */
8127 {
8129 }
8131 /**
8132 * mono_property_get_set_method
8133 * @prop: the MonoProperty to act on.
8134 *
8135 * Returns: the setter method of the property (A MonoMethod)
8136 */
8137 MonoMethod*
8139 {
8141 }
8143 /**
8144 * mono_property_get_get_method
8145 * @prop: the MonoProperty to act on.
8146 *
8147 * Returns: the setter method of the property (A MonoMethod)
8148 */
8149 MonoMethod*
8151 {
8153 }
8155 /**
8156 * mono_property_get_parent:
8157 * @prop: the MonoProperty to act on.
8158 *
8159 * Returns: the MonoClass where the property was defined.
8160 */
8161 MonoClass*
8163 {
8165 }
8167 /**
8168 * mono_property_get_flags:
8169 * @prop: the MonoProperty to act on.
8170 *
8171 * The metadata flags for a property are encoded using the
8172 * PROPERTY_ATTRIBUTE_* constants. See the tabledefs.h file for details.
8173 *
8174 * Returns: the flags for the property.
8175 */
8176 guint32
8178 {
8180 }
8182 /**
8183 * mono_event_get_name:
8184 * @event: the MonoEvent to act on
8185 *
8186 * Returns: the name of the event.
8187 */
8190 {
8192 }
8194 /**
8195 * mono_event_get_add_method:
8196 * @event: The MonoEvent to act on.
8197 *
8198 * Returns: the @add' method for the event (a MonoMethod).
8199 */
8200 MonoMethod*
8202 {
8204 }
8206 /**
8207 * mono_event_get_remove_method:
8208 * @event: The MonoEvent to act on.
8209 *
8210 * Returns: the @remove method for the event (a MonoMethod).
8211 */
8212 MonoMethod*
8214 {
8216 }
8218 /**
8219 * mono_event_get_raise_method:
8220 * @event: The MonoEvent to act on.
8221 *
8222 * Returns: the @raise method for the event (a MonoMethod).
8223 */
8224 MonoMethod*
8226 {
8228 }
8230 /**
8231 * mono_event_get_parent:
8232 * @event: the MonoEvent to act on.
8233 *
8234 * Returns: the MonoClass where the event is defined.
8235 */
8236 MonoClass*
8238 {
8240 }
8242 /**
8243 * mono_event_get_flags
8244 * @event: the MonoEvent to act on.
8245 *
8246 * The metadata flags for an event are encoded using the
8247 * EVENT_* constants. See the tabledefs.h file for details.
8248 *
8249 * Returns: the flags for the event.
8250 */
8251 guint32
8253 {
8255 }
8257 /**
8258 * mono_class_get_method_from_name:
8259 * @klass: where to look for the method
8260 * @name_space: name of the method
8261 * @param_count: number of parameters. -1 for any number.
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 *
8268 {
8270 }
8274 {
8278 /* Search directly in the metadata to avoid calling setup_methods () */
8283 /* class->method.first points into the methodptr table */
8284 mono_metadata_decode_table_row (klass->image, MONO_TABLE_METHOD, klass->method.first + i, cols, MONO_METHOD_SIZE);
8287 method = mono_get_method (klass->image, MONO_TOKEN_METHOD_DEF | (klass->method.first + i + 1), klass);
8291 }
8292 }
8293 }
8296 }
8298 /**
8299 * mono_class_get_method_from_name_flags:
8300 * @klass: where to look for the method
8301 * @name_space: name of the method
8302 * @param_count: number of parameters. -1 for any number.
8303 * @flags: flags which must be set in the method
8304 *
8305 * Obtains a MonoMethod with a given name and number of parameters.
8306 * It only works if there are no multiple signatures for any given method name.
8307 */
8308 MonoMethod *
8309 mono_class_get_method_from_name_flags (MonoClass *klass, const char *name, int param_count, int flags)
8310 {
8317 res = mono_class_get_method_from_name_flags (klass->generic_class->container_class, name, param_count, flags);
8321 }
8325 /*
8326 We can't fail lookup of methods otherwise the runtime will burst in flames on all sort of places.
8327 See mono/tests/array_load_exception.il
8328 FIXME we should better report this error to the caller
8329 */
8341 }
8342 }
8343 }
8346 }
8349 }
8351 /**
8352 * mono_class_set_failure:
8353 * @klass: class in which the failure was detected
8354 * @ex_type: the kind of exception/error to be thrown (later)
8355 * @ex_data: exception data (specific to each type of exception/error)
8356 *
8357 * Keep a detected failure informations in the class for later processing.
8358 * Note that only the first failure is kept.
8359 *
8360 * LOCKING: Acquires the loader lock.
8361 */
8362 gboolean
8364 {
8375 }
8377 /*
8378 * mono_class_get_exception_data:
8379 *
8380 * Return the exception_data property of KLASS.
8381 *
8382 * LOCKING: Acquires the loader lock.
8383 */
8384 gpointer
8386 {
8388 }
8390 /**
8391 * mono_classes_init:
8392 *
8393 * Initialize the resources used by this module.
8394 */
8395 void
8397 {
8408 }
8410 /**
8411 * mono_classes_cleanup:
8412 *
8413 * Free the resources used by this module.
8414 */
8415 void
8417 {
8420 }
8422 /**
8423 * mono_class_get_exception_for_failure:
8424 * @klass: class in which the failure was detected
8425 *
8426 * Return a constructed MonoException than the caller can then throw
8427 * using mono_raise_exception - or NULL if no failure is present (or
8428 * doesn't result in an exception).
8429 */
8430 MonoException*
8432 {
8440 guint32 error = (method) ? MONO_METADATA_INHERITANCEDEMAND_METHOD : MONO_METADATA_INHERITANCEDEMAND_CLASS;
8451 }
8456 char *astr = klass->image->assembly? mono_stringify_assembly_name (&klass->image->assembly->aname): NULL;
8462 }
8468 }
8474 }
8481 ex = mono_get_exception_file_not_found2 (msg, mono_string_new (mono_domain_get (), assembly_name));
8486 }
8489 }
8498 }
8500 /* TODO - handle other class related failures */
8502 }
8503 }
8504 }
8506 static gboolean
8508 {
8517 }
8519 MonoClass *
8521 {
8523 }
8525 /*
8526 * Check if @klass is a subtype of @parent ignoring generic instantiations.
8527 *
8528 * Generic instantiations are ignored for all super types of @klass.
8529 *
8530 * Visibility checks ignoring generic instantiations.
8531 */
8532 gboolean
8534 {
8542 }
8544 }
8545 /*
8546 * Subtype can only access parent members with family protection if the site object
8547 * is subclass of Subtype. For example:
8548 * class A { protected int x; }
8549 * class B : A {
8550 * void valid_access () {
8551 * B b;
8552 * b.x = 0;
8553 * }
8554 * void invalid_access () {
8555 * A a;
8556 * a.x = 0;
8557 * }
8558 * }
8559 * */
8560 static gboolean
8561 is_valid_family_access (MonoClass *access_klass, MonoClass *member_klass, MonoClass *context_klass)
8562 {
8568 /*if access_klass is not member_klass context_klass must be type compat*/
8569 if (access_klass != member_klass && !mono_class_has_parent_and_ignore_generics (context_klass, access_klass))
8572 }
8574 static gboolean
8576 {
8583 /* extra safety under CoreCLR - the runtime does not verify the strongname signatures
8584 * anywhere so untrusted friends are not safe to access platform's code internals */
8588 }
8593 /* Be conservative with checks */
8601 if (!mono_public_tokens_are_equal (friend->public_key_token, accessing->aname.public_key_token))
8603 }
8605 }
8607 }
8609 /*
8610 * If klass is a generic type or if it is derived from a generic type, return the
8611 * MonoClass of the generic definition
8612 * Returns NULL if not found
8613 */
8616 {
8621 }
8623 }
8625 static gboolean
8627 {
8649 }
8650 }
8652 }
8654 static gboolean
8656 {
8667 if (member_klass->byval_arg.type == MONO_TYPE_VAR || member_klass->byval_arg.type == MONO_TYPE_MVAR)
8670 if (member_klass->generic_class && !can_access_instantiation (access_klass, member_klass->generic_class->context.class_inst))
8673 if (is_nesting_type (access_klass, member_klass) || (access_klass->nested_in && is_nesting_type (access_klass->nested_in, member_klass)))
8679 /*Non nested type with nested visibility. We just fail it.*/
8680 if (access_level >= TYPE_ATTRIBUTE_NESTED_PRIVATE && access_level <= TYPE_ATTRIBUTE_NESTED_FAM_OR_ASSEM && member_klass->nested_in == NULL)
8703 return can_access_internals (access_klass->image->assembly, member_klass->nested_in->image->assembly) &&
8707 return can_access_internals (access_klass->image->assembly, member_klass->nested_in->image->assembly) ||
8709 }
8711 }
8713 /* FIXME: check visibility of type, too */
8714 static gboolean
8715 can_access_member (MonoClass *access_klass, MonoClass *member_klass, MonoClass* context_klass, int access_level)
8716 {
8725 else
8730 }
8732 /* Partition I 8.5.3.2 */
8733 /* the access level values are the same for fields and methods */
8736 /* same compilation unit */
8757 }
8759 }
8761 gboolean
8763 {
8764 /* FIXME: check all overlapping fields */
8765 int can = can_access_member (method->klass, field->parent, NULL, field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK);
8769 can = can_access_member (nested, field->parent, NULL, field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK);
8773 }
8774 }
8776 }
8778 gboolean
8780 {
8781 int can = can_access_member (method->klass, called->klass, NULL, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
8785 can = can_access_member (nested, called->klass, NULL, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
8789 }
8790 }
8791 /*
8792 * FIXME:
8793 * with generics calls to explicit interface implementations can be expressed
8794 * directly: the method is private, but we must allow it. This may be opening
8795 * a hole or the generics code should handle this differently.
8796 * Maybe just ensure the interface type is public.
8797 */
8801 }
8803 /*
8804 * mono_method_can_access_method_full:
8805 * @method: The caller method
8806 * @called: The called method
8807 * @context_klass: The static type on stack of the owner @called object used
8808 *
8809 * This function must be used with instance calls, as they have more strict family accessibility.
8810 * It can be used with static methods, but context_klass should be NULL.
8811 *
8812 * Returns: TRUE if caller have proper visibility and acessibility to @called
8813 */
8814 gboolean
8815 mono_method_can_access_method_full (MonoMethod *method, MonoMethod *called, MonoClass *context_klass)
8816 {
8819 int can = can_access_member (access_class, member_class, context_klass, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
8823 can = can_access_member (nested, member_class, context_klass, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
8827 }
8828 }
8833 if (!can_access_type (access_class, member_class) && (!access_class->nested_in || !can_access_type (access_class->nested_in, member_class)))
8838 if (infl->context.method_inst && !can_access_instantiation (access_class, infl->context.method_inst))
8840 }
8843 }
8846 /*
8847 * mono_method_can_access_field_full:
8848 * @method: The caller method
8849 * @field: The accessed field
8850 * @context_klass: The static type on stack of the owner @field object used
8851 *
8852 * This function must be used with instance fields, as they have more strict family accessibility.
8853 * It can be used with static fields, but context_klass should be NULL.
8854 *
8855 * Returns: TRUE if caller have proper visibility and acessibility to @field
8856 */
8857 gboolean
8858 mono_method_can_access_field_full (MonoMethod *method, MonoClassField *field, MonoClass *context_klass)
8859 {
8862 /* FIXME: check all overlapping fields */
8863 int can = can_access_member (access_class, member_class, context_klass, field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK);
8867 can = can_access_member (nested, member_class, context_klass, field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK);
8871 }
8872 }
8877 if (!can_access_type (access_class, member_class) && (!access_class->nested_in || !can_access_type (access_class->nested_in, member_class)))
8880 }
8882 /**
8883 * mono_type_is_valid_enum_basetype:
8884 * @type: The MonoType to check
8885 *
8886 * Returns: TRUE if the type can be used as the basetype of an enum
8887 */
8903 }
8905 }
8907 /**
8908 * mono_class_is_valid_enum:
8909 * @klass: An enum class to be validated
8910 *
8911 * This method verify the required properties an enum should have.
8912 *
8913 * Returns: TRUE if the informed enum class is valid
8914 *
8915 * FIXME: TypeBuilder enums are allowed to implement interfaces, but since they cannot have methods, only empty interfaces are possible
8916 * FIXME: enum types are not allowed to have a cctor, but mono_reflection_create_runtime_class sets has_cctor to 1 for all types
8917 * FIXME: TypeBuilder enums can have any kind of static fields, but the spec is very explicit about that (P II 14.3)
8918 */
8925 /* we cannot test against mono_defaults.enum_class, or mcs won't be able to compile the System namespace*/
8926 if (!klass->parent || strcmp (klass->parent->name, "Enum") || strcmp (klass->parent->name_space, "System") ) {
8928 }
8940 }
8941 }
8950 }
8952 gboolean
8954 {
8955 return gklass->context.class_inst == gklass->container_class->generic_container->context.class_inst;
8956 }
8958 /*
8959 * mono_class_setup_interface_id:
8960 *
8961 * Initializes MonoClass::interface_id if required.
8962 *
8963 * LOCKING: Acquires the loader lock.
8964 */
8965 void
8967 {
8972 }
8974 /*
8975 * mono_class_alloc_ext:
8976 *
8977 * Allocate klass->ext if not already done.
8978 * LOCKING: Assumes the loader lock is held.
8979 */
8980 void
8982 {
8988 }
8990 }
8991 }
8993 /*
8994 * mono_class_setup_interfaces:
8995 *
8996 * Initialize class->interfaces/interfaces_count.
8997 * LOCKING: Acquires the loader lock.
8998 * This function can fail the type.
8999 */
9000 void
9002 {
9015 }
9017 if (klass->rank == 1 && klass->byval_arg.type != MONO_TYPE_ARRAY && mono_defaults.generic_ilist_class) {
9020 /* generic IList, ICollection, IEnumerable */
9022 klass->interfaces = mono_image_alloc0 (klass->image, sizeof (MonoClass*) * klass->interface_count);
9033 klass->interfaces [i] = mono_class_inflate_generic_class_checked (gklass->interfaces [i], mono_generic_class_get_context (klass->generic_class), error);
9035 mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Could not setup the interfaces"));
9039 }
9040 }
9041 }
9048 }