2 * class.c: Class management for the Mono runtime
5 * Miguel de Icaza (miguel@ximian.com)
7 * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
8 * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
19 #include <mono/io-layer/atomic.h>
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>
47 gboolean mono_print_vtable
= FALSE
;
50 guint32 inflated_classes
, inflated_classes_size
, inflated_methods_size
;
51 guint32 classes_size
, class_ext_size
;
53 /* Function supplied by the runtime to find classes by name using information from the AOT file */
54 static MonoGetClassFromName get_class_from_name
= NULL
;
56 static MonoClass
* mono_class_create_from_typedef (MonoImage
*image
, guint32 type_token
);
57 static gboolean
mono_class_get_cached_class_info (MonoClass
*klass
, MonoCachedClassInfo
*res
);
58 static gboolean
can_access_type (MonoClass
*access_klass
, MonoClass
*member_klass
);
59 static MonoMethod
* find_method_in_metadata (MonoClass
*klass
, const char *name
, int param_count
, int flags
);
60 static int generic_array_methods (MonoClass
*class);
61 static void setup_generic_array_ifaces (MonoClass
*class, MonoClass
*iface
, MonoMethod
**methods
, int pos
);
63 static MonoMethod
* mono_class_get_virtual_methods (MonoClass
* klass
, gpointer
*iter
);
64 static char* mono_assembly_name_from_token (MonoImage
*image
, guint32 type_token
);
65 static gboolean
mono_class_is_variant_compatible (MonoClass
*klass
, MonoClass
*oklass
);
68 void (*mono_debugger_class_init_func
) (MonoClass
*klass
) = NULL
;
69 void (*mono_debugger_class_loaded_methods_func
) (MonoClass
*klass
) = NULL
;
72 * mono_class_from_typeref:
74 * @type_token: a TypeRef token
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
82 mono_class_from_typeref (MonoImage
*image
, guint32 type_token
)
84 guint32 cols
[MONO_TYPEREF_SIZE
];
85 MonoTableInfo
*t
= &image
->tables
[MONO_TABLE_TYPEREF
];
87 const char *name
, *nspace
;
91 mono_metadata_decode_row (t
, (type_token
&0xffffff)-1, cols
, MONO_TYPEREF_SIZE
);
93 name
= mono_metadata_string_heap (image
, cols
[MONO_TYPEREF_NAME
]);
94 nspace
= mono_metadata_string_heap (image
, cols
[MONO_TYPEREF_NAMESPACE
]);
96 idx
= cols
[MONO_TYPEREF_SCOPE
] >> MONO_RESOLTION_SCOPE_BITS
;
97 switch (cols
[MONO_TYPEREF_SCOPE
] & MONO_RESOLTION_SCOPE_MASK
) {
98 case MONO_RESOLTION_SCOPE_MODULE
:
100 g_error ("null ResolutionScope not yet handled");
101 /* a typedef in disguise */
102 return mono_class_from_name (image
, nspace
, name
);
103 case MONO_RESOLTION_SCOPE_MODULEREF
:
104 module
= mono_image_load_module (image
, idx
);
106 return mono_class_from_name (module
, nspace
, name
);
108 char *msg
= g_strdup_printf ("%s%s%s", nspace
, nspace
[0] ? "." : "", name
);
111 human_name
= mono_stringify_assembly_name (&image
->assembly
->aname
);
112 mono_loader_set_error_type_load (msg
, human_name
);
118 case MONO_RESOLTION_SCOPE_TYPEREF
: {
119 MonoClass
*enclosing
;
122 if (idx
== mono_metadata_token_index (type_token
)) {
123 mono_loader_set_error_bad_image (g_strdup_printf ("Image %s with self-referencing typeref token %08x.", image
->name
, type_token
));
127 enclosing
= mono_class_from_typeref (image
, MONO_TOKEN_TYPE_REF
| idx
);
131 if (enclosing
->nested_classes_inited
&& enclosing
->ext
) {
132 /* Micro-optimization: don't scan the metadata tables if enclosing is already inited */
133 for (tmp
= enclosing
->ext
->nested_classes
; tmp
; tmp
= tmp
->next
) {
135 if (strcmp (res
->name
, name
) == 0)
139 /* Don't call mono_class_init as we might've been called by it recursively */
140 int i
= mono_metadata_nesting_typedef (enclosing
->image
, enclosing
->type_token
, 1);
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
);
144 const char *nname
= mono_metadata_string_heap (enclosing
->image
, string_offset
);
146 if (strcmp (nname
, name
) == 0)
147 return mono_class_create_from_typedef (enclosing
->image
, MONO_TOKEN_TYPE_DEF
| class_nested
);
149 i
= mono_metadata_nesting_typedef (enclosing
->image
, enclosing
->type_token
, i
+ 1);
152 g_warning ("TypeRef ResolutionScope not yet handled (%d) for %s.%s in image %s", idx
, nspace
, name
, image
->name
);
155 case MONO_RESOLTION_SCOPE_ASSEMBLYREF
:
159 if (idx
> image
->tables
[MONO_TABLE_ASSEMBLYREF
].rows
) {
160 mono_loader_set_error_bad_image (g_strdup_printf ("Image %s with invalid assemblyref token %08x.", image
->name
, idx
));
164 if (!image
->references
|| !image
->references
[idx
- 1])
165 mono_assembly_load_reference (image
, idx
- 1);
166 g_assert (image
->references
[idx
- 1]);
168 /* If the assembly did not load, register this as a type load exception */
169 if (image
->references
[idx
- 1] == REFERENCE_MISSING
){
170 MonoAssemblyName aname
;
173 mono_assembly_get_assemblyref (image
, idx
- 1, &aname
);
174 human_name
= mono_stringify_assembly_name (&aname
);
175 mono_loader_set_error_assembly_load (human_name
, image
->assembly
? image
->assembly
->ref_only
: FALSE
);
181 return mono_class_from_name (image
->references
[idx
- 1]->image
, nspace
, name
);
186 mono_image_memdup (MonoImage
*image
, void *data
, guint size
)
188 void *res
= mono_image_alloc (image
, size
);
189 memcpy (res
, data
, size
);
193 /* Copy everything mono_metadata_free_array free. */
195 mono_dup_array_type (MonoImage
*image
, MonoArrayType
*a
)
198 a
= mono_image_memdup (image
, a
, sizeof (MonoArrayType
));
200 a
->sizes
= mono_image_memdup (image
, a
->sizes
, a
->numsizes
* sizeof (int));
202 a
->lobounds
= mono_image_memdup (image
, a
->lobounds
, a
->numlobounds
* sizeof (int));
204 a
= g_memdup (a
, sizeof (MonoArrayType
));
206 a
->sizes
= g_memdup (a
->sizes
, a
->numsizes
* sizeof (int));
208 a
->lobounds
= g_memdup (a
->lobounds
, a
->numlobounds
* sizeof (int));
213 /* Copy everything mono_metadata_free_method_signature free. */
215 mono_metadata_signature_deep_dup (MonoImage
*image
, MonoMethodSignature
*sig
)
219 sig
= mono_metadata_signature_dup_full (image
, sig
);
221 sig
->ret
= mono_metadata_type_dup (image
, sig
->ret
);
222 for (i
= 0; i
< sig
->param_count
; ++i
)
223 sig
->params
[i
] = mono_metadata_type_dup (image
, sig
->params
[i
]);
229 _mono_type_get_assembly_name (MonoClass
*klass
, GString
*str
)
231 MonoAssembly
*ta
= klass
->image
->assembly
;
233 g_string_append_printf (
234 str
, ", %s, Version=%d.%d.%d.%d, Culture=%s, PublicKeyToken=%s%s",
236 ta
->aname
.major
, ta
->aname
.minor
, ta
->aname
.build
, ta
->aname
.revision
,
237 ta
->aname
.culture
&& *ta
->aname
.culture
? ta
->aname
.culture
: "neutral",
238 ta
->aname
.public_key_token
[0] ? (char *)ta
->aname
.public_key_token
: "null",
239 (ta
->aname
.flags
& ASSEMBLYREF_RETARGETABLE_FLAG
) ? ", Retargetable=Yes" : "");
243 mono_type_name_check_byref (MonoType
*type
, GString
*str
)
246 g_string_append_c (str
, '&');
250 mono_type_get_name_recurse (MonoType
*type
, GString
*str
, gboolean is_recursed
,
251 MonoTypeNameFormat format
)
255 switch (type
->type
) {
256 case MONO_TYPE_ARRAY
: {
257 int i
, rank
= type
->data
.array
->rank
;
258 MonoTypeNameFormat nested_format
;
260 nested_format
= format
== MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED
?
261 MONO_TYPE_NAME_FORMAT_FULL_NAME
: format
;
263 mono_type_get_name_recurse (
264 &type
->data
.array
->eklass
->byval_arg
, str
, FALSE
, nested_format
);
265 g_string_append_c (str
, '[');
267 g_string_append_c (str
, '*');
268 for (i
= 1; i
< rank
; i
++)
269 g_string_append_c (str
, ',');
270 g_string_append_c (str
, ']');
272 mono_type_name_check_byref (type
, str
);
274 if (format
== MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED
)
275 _mono_type_get_assembly_name (type
->data
.array
->eklass
, str
);
278 case MONO_TYPE_SZARRAY
: {
279 MonoTypeNameFormat nested_format
;
281 nested_format
= format
== MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED
?
282 MONO_TYPE_NAME_FORMAT_FULL_NAME
: format
;
284 mono_type_get_name_recurse (
285 &type
->data
.klass
->byval_arg
, str
, FALSE
, nested_format
);
286 g_string_append (str
, "[]");
288 mono_type_name_check_byref (type
, str
);
290 if (format
== MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED
)
291 _mono_type_get_assembly_name (type
->data
.klass
, str
);
294 case MONO_TYPE_PTR
: {
295 MonoTypeNameFormat nested_format
;
297 nested_format
= format
== MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED
?
298 MONO_TYPE_NAME_FORMAT_FULL_NAME
: format
;
300 mono_type_get_name_recurse (
301 type
->data
.type
, str
, FALSE
, nested_format
);
302 g_string_append_c (str
, '*');
304 mono_type_name_check_byref (type
, str
);
306 if (format
== MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED
)
307 _mono_type_get_assembly_name (mono_class_from_mono_type (type
->data
.type
), str
);
312 if (!mono_generic_param_info (type
->data
.generic_param
))
313 g_string_append_printf (str
, "%s%d", type
->type
== MONO_TYPE_VAR
? "!" : "!!", type
->data
.generic_param
->num
);
315 g_string_append (str
, mono_generic_param_info (type
->data
.generic_param
)->name
);
317 mono_type_name_check_byref (type
, str
);
321 klass
= mono_class_from_mono_type (type
);
322 if (klass
->nested_in
) {
323 mono_type_get_name_recurse (
324 &klass
->nested_in
->byval_arg
, str
, TRUE
, format
);
325 if (format
== MONO_TYPE_NAME_FORMAT_IL
)
326 g_string_append_c (str
, '.');
328 g_string_append_c (str
, '+');
329 } else if (*klass
->name_space
) {
330 g_string_append (str
, klass
->name_space
);
331 g_string_append_c (str
, '.');
333 if (format
== MONO_TYPE_NAME_FORMAT_IL
) {
334 char *s
= strchr (klass
->name
, '`');
335 int len
= s
? s
- klass
->name
: strlen (klass
->name
);
337 g_string_append_len (str
, klass
->name
, len
);
339 g_string_append (str
, klass
->name
);
342 if (klass
->generic_class
) {
343 MonoGenericClass
*gclass
= klass
->generic_class
;
344 MonoGenericInst
*inst
= gclass
->context
.class_inst
;
345 MonoTypeNameFormat nested_format
;
348 nested_format
= format
== MONO_TYPE_NAME_FORMAT_FULL_NAME
?
349 MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED
: format
;
351 if (format
== MONO_TYPE_NAME_FORMAT_IL
)
352 g_string_append_c (str
, '<');
354 g_string_append_c (str
, '[');
355 for (i
= 0; i
< inst
->type_argc
; i
++) {
356 MonoType
*t
= inst
->type_argv
[i
];
359 g_string_append_c (str
, ',');
360 if ((nested_format
== MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED
) &&
361 (t
->type
!= MONO_TYPE_VAR
) && (type
->type
!= MONO_TYPE_MVAR
))
362 g_string_append_c (str
, '[');
363 mono_type_get_name_recurse (inst
->type_argv
[i
], str
, FALSE
, nested_format
);
364 if ((nested_format
== MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED
) &&
365 (t
->type
!= MONO_TYPE_VAR
) && (type
->type
!= MONO_TYPE_MVAR
))
366 g_string_append_c (str
, ']');
368 if (format
== MONO_TYPE_NAME_FORMAT_IL
)
369 g_string_append_c (str
, '>');
371 g_string_append_c (str
, ']');
372 } else if (klass
->generic_container
&&
373 (format
!= MONO_TYPE_NAME_FORMAT_FULL_NAME
) &&
374 (format
!= MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED
)) {
377 if (format
== MONO_TYPE_NAME_FORMAT_IL
)
378 g_string_append_c (str
, '<');
380 g_string_append_c (str
, '[');
381 for (i
= 0; i
< klass
->generic_container
->type_argc
; i
++) {
383 g_string_append_c (str
, ',');
384 g_string_append (str
, mono_generic_container_get_param_info (klass
->generic_container
, i
)->name
);
386 if (format
== MONO_TYPE_NAME_FORMAT_IL
)
387 g_string_append_c (str
, '>');
389 g_string_append_c (str
, ']');
392 mono_type_name_check_byref (type
, str
);
394 if ((format
== MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED
) &&
395 (type
->type
!= MONO_TYPE_VAR
) && (type
->type
!= MONO_TYPE_MVAR
))
396 _mono_type_get_assembly_name (klass
, str
);
402 * mono_type_get_name_full:
404 * @format: the format for the return string.
407 * Returns: the string representation in a number of formats:
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 ().
413 * if format is MONO_TYPE_NAME_FORMAT_IL, it returns a syntax that can
414 * be used by the IL assembler.
416 * if format is MONO_TYPE_NAME_FORMAT_FULL_NAME
418 * if format is MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED
421 mono_type_get_name_full (MonoType
*type
, MonoTypeNameFormat format
)
425 result
= g_string_new ("");
427 mono_type_get_name_recurse (type
, result
, FALSE
, format
);
429 return g_string_free (result
, FALSE
);
433 * mono_type_get_full_name:
436 * Returns: the string representation for type as required by System.Reflection.
437 * The inverse of mono_reflection_parse_type ().
440 mono_type_get_full_name (MonoClass
*class)
442 return mono_type_get_name_full (mono_class_get_type (class), MONO_TYPE_NAME_FORMAT_REFLECTION
);
446 * mono_type_get_name:
449 * Returns: the string representation for type as it would be represented in IL code.
452 mono_type_get_name (MonoType
*type
)
454 return mono_type_get_name_full (type
, MONO_TYPE_NAME_FORMAT_IL
);
458 * mono_type_get_underlying_type:
461 * Returns: the MonoType for the underlying integer type if @type
462 * is an enum and byref is false, otherwise the type itself.
465 mono_type_get_underlying_type (MonoType
*type
)
467 if (type
->type
== MONO_TYPE_VALUETYPE
&& type
->data
.klass
->enumtype
&& !type
->byref
)
468 return mono_class_enum_basetype (type
->data
.klass
);
469 if (type
->type
== MONO_TYPE_GENERICINST
&& type
->data
.generic_class
->container_class
->enumtype
&& !type
->byref
)
470 return mono_class_enum_basetype (type
->data
.generic_class
->container_class
);
475 * mono_class_is_open_constructed_type:
478 * Returns TRUE if type represents a generics open constructed type
479 * (not all the type parameters required for the instantiation have
483 mono_class_is_open_constructed_type (MonoType
*t
)
489 case MONO_TYPE_SZARRAY
:
490 return mono_class_is_open_constructed_type (&t
->data
.klass
->byval_arg
);
491 case MONO_TYPE_ARRAY
:
492 return mono_class_is_open_constructed_type (&t
->data
.array
->eklass
->byval_arg
);
494 return mono_class_is_open_constructed_type (t
->data
.type
);
495 case MONO_TYPE_GENERICINST
:
496 return t
->data
.generic_class
->context
.class_inst
->is_open
;
503 inflate_generic_type (MonoImage
*image
, MonoType
*type
, MonoGenericContext
*context
, MonoError
*error
)
505 mono_error_init (error
);
507 switch (type
->type
) {
508 case MONO_TYPE_MVAR
: {
510 int num
= mono_type_get_generic_param_num (type
);
511 MonoGenericInst
*inst
= context
->method_inst
;
512 if (!inst
|| !inst
->type_argv
)
514 if (num
>= inst
->type_argc
) {
515 MonoGenericParamInfo
*info
= mono_generic_param_info (type
->data
.generic_param
);
516 mono_error_set_bad_image (error
, image
, "MVAR %d (%s) cannot be expanded in this context with %d instantiations",
517 num
, info
? info
->name
: "", inst
->type_argc
);
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.
526 nt
= mono_metadata_type_dup (image
, inst
->type_argv
[num
]);
527 nt
->byref
= type
->byref
;
528 nt
->attrs
= type
->attrs
;
531 case MONO_TYPE_VAR
: {
533 int num
= mono_type_get_generic_param_num (type
);
534 MonoGenericInst
*inst
= context
->class_inst
;
537 if (num
>= inst
->type_argc
) {
538 MonoGenericParamInfo
*info
= mono_generic_param_info (type
->data
.generic_param
);
539 mono_error_set_bad_image (error
, image
, "VAR %d (%s) cannot be expanded in this context with %d instantiations",
540 num
, info
? info
->name
: "", inst
->type_argc
);
543 nt
= mono_metadata_type_dup (image
, inst
->type_argv
[num
]);
544 nt
->byref
= type
->byref
;
545 nt
->attrs
= type
->attrs
;
548 case MONO_TYPE_SZARRAY
: {
549 MonoClass
*eclass
= type
->data
.klass
;
550 MonoType
*nt
, *inflated
= inflate_generic_type (NULL
, &eclass
->byval_arg
, context
, error
);
551 if (!inflated
|| !mono_error_ok (error
))
553 nt
= mono_metadata_type_dup (image
, type
);
554 nt
->data
.klass
= mono_class_from_mono_type (inflated
);
555 mono_metadata_free_type (inflated
);
558 case MONO_TYPE_ARRAY
: {
559 MonoClass
*eclass
= type
->data
.array
->eklass
;
560 MonoType
*nt
, *inflated
= inflate_generic_type (NULL
, &eclass
->byval_arg
, context
, error
);
561 if (!inflated
|| !mono_error_ok (error
))
563 nt
= mono_metadata_type_dup (image
, type
);
564 nt
->data
.array
->eklass
= mono_class_from_mono_type (inflated
);
565 mono_metadata_free_type (inflated
);
568 case MONO_TYPE_GENERICINST
: {
569 MonoGenericClass
*gclass
= type
->data
.generic_class
;
570 MonoGenericInst
*inst
;
572 if (!gclass
->context
.class_inst
->is_open
)
575 inst
= mono_metadata_inflate_generic_inst (gclass
->context
.class_inst
, context
, error
);
576 if (!mono_error_ok (error
))
578 if (inst
!= gclass
->context
.class_inst
)
579 gclass
= mono_metadata_lookup_generic_class (gclass
->container_class
, inst
, gclass
->is_dynamic
);
581 if (gclass
== type
->data
.generic_class
)
584 nt
= mono_metadata_type_dup (image
, type
);
585 nt
->data
.generic_class
= gclass
;
588 case MONO_TYPE_CLASS
:
589 case MONO_TYPE_VALUETYPE
: {
590 MonoClass
*klass
= type
->data
.klass
;
591 MonoGenericContainer
*container
= klass
->generic_container
;
592 MonoGenericInst
*inst
;
593 MonoGenericClass
*gclass
= NULL
;
599 /* We can't use context->class_inst directly, since it can have more elements */
600 inst
= mono_metadata_inflate_generic_inst (container
->context
.class_inst
, context
, error
);
601 if (!mono_error_ok (error
))
603 if (inst
== container
->context
.class_inst
)
606 gclass
= mono_metadata_lookup_generic_class (klass
, inst
, klass
->image
->dynamic
);
608 nt
= mono_metadata_type_dup (image
, type
);
609 nt
->type
= MONO_TYPE_GENERICINST
;
610 nt
->data
.generic_class
= gclass
;
620 mono_generic_class_get_context (MonoGenericClass
*gclass
)
622 return &gclass
->context
;
626 mono_class_get_context (MonoClass
*class)
628 return class->generic_class
? mono_generic_class_get_context (class->generic_class
) : NULL
;
632 * mono_class_get_generic_container:
634 * Return the generic container of KLASS which should be a generic type definition.
636 MonoGenericContainer
*
637 mono_class_get_generic_container (MonoClass
*klass
)
639 g_assert (klass
->is_generic
);
641 return klass
->generic_container
;
645 * mono_class_get_generic_class:
647 * Return the MonoGenericClass of KLASS, which should be a generic instance.
650 mono_class_get_generic_class (MonoClass
*klass
)
652 g_assert (klass
->is_inflated
);
654 return klass
->generic_class
;
658 * mono_class_inflate_generic_type_with_mempool:
659 * @mempool: a mempool
661 * @context: a generics context
662 * @error: error context
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 ().
671 mono_class_inflate_generic_type_with_mempool (MonoImage
*image
, MonoType
*type
, MonoGenericContext
*context
, MonoError
*error
)
673 MonoType
*inflated
= NULL
;
674 mono_error_init (error
);
677 inflated
= inflate_generic_type (image
, type
, context
, error
);
678 if (!mono_error_ok (error
))
682 MonoType
*shared
= mono_metadata_get_shared_type (type
);
687 return mono_metadata_type_dup (image
, type
);
691 mono_stats
.inflated_type_count
++;
696 * mono_class_inflate_generic_type:
698 * @context: a generics context
700 * If @type is a generic type and @context is not NULL, instantiate it using the
701 * generics context @context.
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.
706 * @deprecated Please use mono_class_inflate_generic_type_checked instead
709 mono_class_inflate_generic_type (MonoType
*type
, MonoGenericContext
*context
)
713 result
= mono_class_inflate_generic_type_checked (type
, context
, &error
);
715 if (!mono_error_ok (&error
)) {
716 mono_error_cleanup (&error
);
723 * mono_class_inflate_generic_type:
725 * @context: a generics context
726 * @error: error context to use
728 * If @type is a generic type and @context is not NULL, instantiate it using the
729 * generics context @context.
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.
735 mono_class_inflate_generic_type_checked (MonoType
*type
, MonoGenericContext
*context
, MonoError
*error
)
737 return mono_class_inflate_generic_type_with_mempool (NULL
, type
, context
, error
);
741 * mono_class_inflate_generic_type_no_copy:
743 * Same as inflate_generic_type_with_mempool, but return TYPE if no inflation
747 mono_class_inflate_generic_type_no_copy (MonoImage
*image
, MonoType
*type
, MonoGenericContext
*context
, MonoError
*error
)
749 MonoType
*inflated
= NULL
;
751 mono_error_init (error
);
753 inflated
= inflate_generic_type (image
, type
, context
, error
);
754 if (!mono_error_ok (error
))
761 mono_stats
.inflated_type_count
++;
766 mono_class_inflate_generic_class_checked (MonoClass
*gklass
, MonoGenericContext
*context
, MonoError
*error
)
771 inflated
= mono_class_inflate_generic_type_checked (&gklass
->byval_arg
, context
, error
);
772 if (!mono_error_ok (error
))
775 res
= mono_class_from_mono_type (inflated
);
776 mono_metadata_free_type (inflated
);
781 * mono_class_inflate_generic_class:
783 * Inflate the class GKLASS with CONTEXT.
786 mono_class_inflate_generic_class (MonoClass
*gklass
, MonoGenericContext
*context
)
791 res
= mono_class_inflate_generic_class_checked (gklass
, context
, &error
);
792 g_assert (mono_error_ok (&error
)); /*FIXME proper error handling*/
799 static MonoGenericContext
800 inflate_generic_context (MonoGenericContext
*context
, MonoGenericContext
*inflate_with
, MonoError
*error
)
802 MonoGenericInst
*class_inst
= NULL
;
803 MonoGenericInst
*method_inst
= NULL
;
804 MonoGenericContext res
= { NULL
, NULL
};
806 mono_error_init (error
);
808 if (context
->class_inst
) {
809 class_inst
= mono_metadata_inflate_generic_inst (context
->class_inst
, inflate_with
, error
);
810 if (!mono_error_ok (error
))
814 if (context
->method_inst
) {
815 method_inst
= mono_metadata_inflate_generic_inst (context
->method_inst
, inflate_with
, error
);
816 if (!mono_error_ok (error
))
820 res
.class_inst
= class_inst
;
821 res
.method_inst
= method_inst
;
827 * mono_class_inflate_generic_method:
828 * @method: a generic method
829 * @context: a generics context
831 * Instantiate the generic method @method using the generics context @context.
833 * Returns: the new instantiated method
836 mono_class_inflate_generic_method (MonoMethod
*method
, MonoGenericContext
*context
)
838 return mono_class_inflate_generic_method_full (method
, NULL
, context
);
842 * mono_class_inflate_generic_method_full:
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.
849 mono_class_inflate_generic_method_full (MonoMethod
*method
, MonoClass
*klass_hint
, MonoGenericContext
*context
)
852 MonoMethod
*res
= mono_class_inflate_generic_method_full_checked (method
, klass_hint
, context
, &error
);
853 if (!mono_error_ok (&error
))
854 /*FIXME do proper error handling - on this case, kill this function. */
855 g_error ("Could not inflate generic method due to %s", mono_error_get_message (&error
));
861 * mono_class_inflate_generic_method_full_checked:
862 * Same as mono_class_inflate_generic_method_full but return failure using @error.
865 mono_class_inflate_generic_method_full_checked (MonoMethod
*method
, MonoClass
*klass_hint
, MonoGenericContext
*context
, MonoError
*error
)
868 MonoMethodInflated
*iresult
, *cached
;
869 MonoMethodSignature
*sig
;
870 MonoGenericContext tmp_context
;
871 gboolean is_mb_open
= FALSE
;
873 mono_error_init (error
);
875 /* The `method' has already been instantiated before => we need to peel out the instantiation and create a new context */
876 while (method
->is_inflated
) {
877 MonoGenericContext
*method_context
= mono_method_get_context (method
);
878 MonoMethodInflated
*imethod
= (MonoMethodInflated
*) method
;
880 tmp_context
= inflate_generic_context (method_context
, context
, error
);
881 if (!mono_error_ok (error
))
883 context
= &tmp_context
;
885 if (mono_metadata_generic_context_equal (method_context
, context
))
888 method
= imethod
->declaring
;
891 if (!method
->is_generic
&& !method
->klass
->generic_container
)
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.
899 * This happens, for example, when we want to emit a recursive generic method. Given the following C# code:
901 * void Example<T> () {
905 * In Example, the method token must be encoded as: "void Example<!!0>()"
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.
910 * On the other hand, inflating a non-SRE generic method with its own arguments should
911 * return itself. For example:
913 * MethodInfo m = ... //m is a generic method definition
914 * MethodInfo res = m.MakeGenericMethod (m.GetGenericArguments ());
917 * To allow such scenarios we must allow inflation of MethodBuilder to happen in a diferent way than
918 * what happens with regular methods.
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.
924 is_mb_open
= method
->is_generic
&&
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. */
928 iresult
= g_new0 (MonoMethodInflated
, 1);
929 iresult
->context
= *context
;
930 iresult
->declaring
= method
;
931 iresult
->method
.method
.is_mb_open
= is_mb_open
;
933 if (!context
->method_inst
&& method
->is_generic
)
934 iresult
->context
.method_inst
= mono_method_get_generic_container (method
)->context
.method_inst
;
936 if (!context
->class_inst
) {
937 g_assert (!iresult
->declaring
->klass
->generic_class
);
938 if (iresult
->declaring
->klass
->generic_container
)
939 iresult
->context
.class_inst
= iresult
->declaring
->klass
->generic_container
->context
.class_inst
;
940 else if (iresult
->declaring
->klass
->generic_class
)
941 iresult
->context
.class_inst
= iresult
->declaring
->klass
->generic_class
->context
.class_inst
;
945 cached
= mono_method_inflated_lookup (iresult
, FALSE
);
947 mono_loader_unlock ();
949 return (MonoMethod
*)cached
;
952 mono_stats
.inflated_method_count
++;
954 inflated_methods_size
+= sizeof (MonoMethodInflated
);
956 sig
= mono_method_signature (method
);
958 char *name
= mono_type_get_full_name (method
->klass
);
959 mono_error_set_bad_image (error
, method
->klass
->image
, "Could not resolve signature of method %s:%s", name
, method
->name
);
965 memcpy (&iresult
->method
.pinvoke
, method
, sizeof (MonoMethodPInvoke
));
967 memcpy (&iresult
->method
.method
, method
, sizeof (MonoMethod
));
970 result
= (MonoMethod
*) iresult
;
971 result
->is_inflated
= TRUE
;
972 result
->is_generic
= FALSE
;
973 result
->sre_method
= FALSE
;
974 result
->signature
= NULL
;
975 result
->is_mb_open
= is_mb_open
;
977 if (!context
->method_inst
) {
978 /* Set the generic_container of the result to the generic_container of method */
979 MonoGenericContainer
*generic_container
= mono_method_get_generic_container (method
);
981 if (generic_container
) {
982 result
->is_generic
= 1;
983 mono_method_set_generic_container (result
, generic_container
);
987 if (!klass_hint
|| !klass_hint
->generic_class
||
988 klass_hint
->generic_class
->container_class
!= method
->klass
||
989 klass_hint
->generic_class
->context
.class_inst
!= context
->class_inst
)
992 if (method
->klass
->generic_container
)
993 result
->klass
= klass_hint
;
995 if (!result
->klass
) {
996 MonoType
*inflated
= inflate_generic_type (NULL
, &method
->klass
->byval_arg
, context
, error
);
997 if (!mono_error_ok (error
))
1000 result
->klass
= inflated
? mono_class_from_mono_type (inflated
) : method
->klass
;
1002 mono_metadata_free_type (inflated
);
1005 mono_method_inflated_lookup (iresult
, TRUE
);
1006 mono_loader_unlock ();
1010 mono_loader_unlock ();
1016 * mono_get_inflated_method:
1018 * Obsolete. We keep it around since it's mentioned in the public API.
1021 mono_get_inflated_method (MonoMethod
*method
)
1027 * mono_method_get_context_general:
1029 * @uninflated: handle uninflated methods?
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.
1037 mono_method_get_context_general (MonoMethod
*method
, gboolean uninflated
)
1039 if (method
->is_inflated
) {
1040 MonoMethodInflated
*imethod
= (MonoMethodInflated
*) method
;
1041 return &imethod
->context
;
1045 if (method
->is_generic
)
1046 return &(mono_method_get_generic_container (method
)->context
);
1047 if (method
->klass
->generic_container
)
1048 return &method
->klass
->generic_container
->context
;
1053 * mono_method_get_context:
1056 * Returns the generic context for method if it's inflated, otherwise
1060 mono_method_get_context (MonoMethod
*method
)
1062 return mono_method_get_context_general (method
, FALSE
);
1066 * mono_method_get_generic_container:
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.
1072 MonoGenericContainer
*
1073 mono_method_get_generic_container (MonoMethod
*method
)
1075 MonoGenericContainer
*container
;
1077 if (!method
->is_generic
)
1080 container
= mono_image_property_lookup (method
->klass
->image
, method
, MONO_METHOD_PROP_GENERIC_CONTAINER
);
1081 g_assert (container
);
1087 * mono_method_set_generic_container:
1089 * Sets the generic container of METHOD to CONTAINER.
1090 * LOCKING: Acquires the loader lock.
1093 mono_method_set_generic_container (MonoMethod
*method
, MonoGenericContainer
* container
)
1095 g_assert (method
->is_generic
);
1097 mono_image_property_insert (method
->klass
->image
, method
, MONO_METHOD_PROP_GENERIC_CONTAINER
, container
);
1101 * mono_class_find_enum_basetype:
1102 * @class: The enum class
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.
1108 mono_class_find_enum_basetype (MonoClass
*class)
1110 MonoGenericContainer
*container
= NULL
;
1111 MonoImage
*m
= class->image
;
1112 const int top
= class->field
.count
;
1115 g_assert (class->enumtype
);
1117 if (class->generic_container
)
1118 container
= class->generic_container
;
1119 else if (class->generic_class
) {
1120 MonoClass
*gklass
= class->generic_class
->container_class
;
1122 container
= gklass
->generic_container
;
1123 g_assert (container
);
1127 * Fetch all the field information.
1129 for (i
= 0; i
< top
; i
++){
1131 guint32 cols
[MONO_FIELD_SIZE
];
1132 int idx
= class->field
.first
+ i
;
1135 /* class->field.first and idx points into the fieldptr table */
1136 mono_metadata_decode_table_row (m
, MONO_TABLE_FIELD
, idx
, cols
, MONO_FIELD_SIZE
);
1138 if (cols
[MONO_FIELD_FLAGS
] & FIELD_ATTRIBUTE_STATIC
) //no need to decode static fields
1141 if (!mono_verifier_verify_field_signature (class->image
, cols
[MONO_FIELD_SIGNATURE
], NULL
))
1144 sig
= mono_metadata_blob_heap (m
, cols
[MONO_FIELD_SIGNATURE
]);
1145 mono_metadata_decode_value (sig
, &sig
);
1146 /* FIELD signature == 0x06 */
1150 ftype
= mono_metadata_parse_type_full (m
, container
, MONO_PARSE_FIELD
, cols
[MONO_FIELD_FLAGS
], sig
+ 1, &sig
);
1153 if (class->generic_class
) {
1154 //FIXME do we leak here?
1155 ftype
= mono_class_inflate_generic_type (ftype
, mono_class_get_context (class));
1156 ftype
->attrs
= cols
[MONO_FIELD_FLAGS
];
1166 * Checks for MonoClass::exception_type without resolving all MonoType's into MonoClass'es
1169 mono_type_has_exceptions (MonoType
*type
)
1171 switch (type
->type
) {
1172 case MONO_TYPE_CLASS
:
1173 case MONO_TYPE_VALUETYPE
:
1174 case MONO_TYPE_SZARRAY
:
1175 return type
->data
.klass
->exception_type
;
1176 case MONO_TYPE_ARRAY
:
1177 return type
->data
.array
->eklass
->exception_type
;
1178 case MONO_TYPE_GENERICINST
:
1179 return mono_generic_class_get_class (type
->data
.generic_class
)->exception_type
;
1187 * Allocate memory for some data belonging to CLASS, either from its image's mempool,
1191 mono_class_alloc (MonoClass
*class, int size
)
1193 if (class->generic_class
)
1195 * This should be freed in free_generic_class () in metadata.c.
1196 * FIXME: It would be better to allocate this from the image set mempool, by
1197 * adding an image_set field to MonoGenericClass.
1199 return g_malloc (size
);
1201 return mono_image_alloc (class->image
, size
);
1205 mono_class_alloc0 (MonoClass
*class, int size
)
1209 res
= mono_class_alloc (class, size
);
1210 memset (res
, 0, size
);
1214 #define mono_class_new0(class,struct_type, n_structs) \
1215 ((struct_type *) mono_class_alloc0 ((class), ((gsize) sizeof (struct_type)) * ((gsize) (n_structs))))
1218 * mono_class_setup_fields:
1219 * @class: The class to initialize
1221 * Initializes the class->fields.
1222 * LOCKING: Assumes the loader lock is held.
1225 mono_class_setup_fields (MonoClass
*class)
1228 MonoImage
*m
= class->image
;
1229 int top
= class->field
.count
;
1230 guint32 layout
= class->flags
& TYPE_ATTRIBUTE_LAYOUT_MASK
;
1231 int i
, blittable
= TRUE
;
1232 guint32 real_size
= 0;
1233 guint32 packing_size
= 0;
1234 gboolean explicit_size
;
1235 MonoClassField
*field
;
1236 MonoGenericContainer
*container
= NULL
;
1237 MonoClass
*gtd
= class->generic_class
? mono_class_get_generic_type_definition (class) : NULL
;
1239 if (class->size_inited
)
1242 if (class->generic_class
&& class->generic_class
->container_class
->image
->dynamic
&& !class->generic_class
->container_class
->wastypebuilder
) {
1244 * This happens when a generic instance of an unfinished generic typebuilder
1245 * is used as an element type for creating an array type. We can't initialize
1246 * the fields of this class using the fields of gklass, since gklass is not
1247 * finished yet, fields could be added to it later.
1253 mono_class_setup_fields (gtd
);
1254 if (gtd
->exception_type
) {
1255 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, NULL
);
1259 top
= gtd
->field
.count
;
1260 class->field
.first
= gtd
->field
.first
;
1261 class->field
.count
= gtd
->field
.count
;
1264 class->instance_size
= 0;
1266 class->sizes
.class_size
= 0;
1268 if (class->parent
) {
1269 /* For generic instances, class->parent might not have been initialized */
1270 mono_class_init (class->parent
);
1271 if (!class->parent
->size_inited
) {
1272 mono_class_setup_fields (class->parent
);
1273 if (class->parent
->exception_type
) {
1274 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, NULL
);
1278 class->instance_size
+= class->parent
->instance_size
;
1279 class->min_align
= class->parent
->min_align
;
1280 /* we use |= since it may have been set already */
1281 class->has_references
|= class->parent
->has_references
;
1282 blittable
= class->parent
->blittable
;
1284 class->instance_size
= sizeof (MonoObject
);
1285 class->min_align
= 1;
1288 /* We can't really enable 16 bytes alignment until the GC supports it.
1289 The whole layout/instance size code must be reviewed because we do alignment calculation in terms of the
1290 boxed instance, which leads to unexplainable holes at the beginning of an object embedding a simd type.
1291 Bug #506144 is an example of this issue.
1293 if (class->simd_type)
1294 class->min_align = 16;
1296 /* Get the real size */
1297 explicit_size
= mono_metadata_packing_from_typedef (class->image
, class->type_token
, &packing_size
, &real_size
);
1299 if (explicit_size
) {
1300 g_assert ((packing_size
& 0xfffffff0) == 0);
1301 class->packing_size
= packing_size
;
1302 real_size
+= class->instance_size
;
1306 if (explicit_size
&& real_size
) {
1307 class->instance_size
= MAX (real_size
, class->instance_size
);
1309 class->size_inited
= 1;
1310 class->blittable
= blittable
;
1314 if (layout
== TYPE_ATTRIBUTE_AUTO_LAYOUT
)
1317 /* Prevent infinite loops if the class references itself */
1318 class->size_inited
= 1;
1320 class->fields
= mono_class_alloc0 (class, sizeof (MonoClassField
) * top
);
1322 if (class->generic_container
) {
1323 container
= class->generic_container
;
1325 container
= gtd
->generic_container
;
1326 g_assert (container
);
1330 * Fetch all the field information.
1332 for (i
= 0; i
< top
; i
++){
1333 int idx
= class->field
.first
+ i
;
1334 field
= &class->fields
[i
];
1336 field
->parent
= class;
1339 MonoClassField
*gfield
= >d
->fields
[i
];
1341 field
->name
= mono_field_get_name (gfield
);
1342 /*This memory must come from the image mempool as we don't have a chance to free it.*/
1343 field
->type
= mono_class_inflate_generic_type_no_copy (class->image
, gfield
->type
, mono_class_get_context (class), &error
);
1344 if (!mono_error_ok (&error
)) {
1345 char *err_msg
= g_strdup_printf ("Could not load field %d type due to: %s", i
, mono_error_get_message (&error
));
1346 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, err_msg
);
1348 mono_error_cleanup (&error
);
1351 g_assert (field
->type
->attrs
== gfield
->type
->attrs
);
1352 if (mono_field_is_deleted (field
))
1354 field
->offset
= gfield
->offset
;
1357 guint32 cols
[MONO_FIELD_SIZE
];
1359 /* class->field.first and idx points into the fieldptr table */
1360 mono_metadata_decode_table_row (m
, MONO_TABLE_FIELD
, idx
, cols
, MONO_FIELD_SIZE
);
1361 /* The name is needed for fieldrefs */
1362 field
->name
= mono_metadata_string_heap (m
, cols
[MONO_FIELD_NAME
]);
1363 if (!mono_verifier_verify_field_signature (class->image
, cols
[MONO_FIELD_SIGNATURE
], NULL
)) {
1364 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, NULL
);
1367 sig
= mono_metadata_blob_heap (m
, cols
[MONO_FIELD_SIGNATURE
]);
1368 mono_metadata_decode_value (sig
, &sig
);
1369 /* FIELD signature == 0x06 */
1370 g_assert (*sig
== 0x06);
1371 field
->type
= mono_metadata_parse_type_full (m
, container
, MONO_PARSE_FIELD
, cols
[MONO_FIELD_FLAGS
], sig
+ 1, &sig
);
1373 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, NULL
);
1376 if (mono_field_is_deleted (field
))
1378 if (layout
== TYPE_ATTRIBUTE_EXPLICIT_LAYOUT
) {
1380 mono_metadata_field_info (m
, idx
, &offset
, NULL
, NULL
);
1381 field
->offset
= offset
;
1383 if (field
->offset
== (guint32
)-1 && !(field
->type
->attrs
& FIELD_ATTRIBUTE_STATIC
)) {
1384 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, g_strdup_printf ("Missing field layout info for %s", field
->name
));
1387 if (field
->offset
< -1) { /*-1 is used to encode special static fields */
1388 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, g_strdup_printf ("Invalid negative field offset %d for %s", field
->offset
, field
->name
));
1394 /* Only do these checks if we still think this type is blittable */
1395 if (blittable
&& !(field
->type
->attrs
& FIELD_ATTRIBUTE_STATIC
)) {
1396 if (field
->type
->byref
|| MONO_TYPE_IS_REFERENCE (field
->type
)) {
1399 MonoClass
*field_class
= mono_class_from_mono_type (field
->type
);
1401 mono_class_setup_fields (field_class
);
1402 if (field_class
->exception_type
) {
1403 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, NULL
);
1407 if (!field_class
|| !field_class
->blittable
)
1412 if (class->enumtype
&& !(field
->type
->attrs
& FIELD_ATTRIBUTE_STATIC
)) {
1413 class->cast_class
= class->element_class
= mono_class_from_mono_type (field
->type
);
1414 blittable
= class->element_class
->blittable
;
1417 if (mono_type_has_exceptions (field
->type
)) {
1418 char *class_name
= mono_type_get_full_name (class);
1419 char *type_name
= mono_type_full_name (field
->type
);
1421 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, NULL
);
1422 g_warning ("Invalid type %s for instance field %s:%s", type_name
, class_name
, field
->name
);
1423 g_free (class_name
);
1427 /* The def_value of fields is compute lazily during vtable creation */
1430 if (class == mono_defaults
.string_class
)
1433 class->blittable
= blittable
;
1435 if (class->enumtype
&& !mono_class_enum_basetype (class)) {
1436 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, NULL
);
1439 if (explicit_size
&& real_size
) {
1440 class->instance_size
= MAX (real_size
, class->instance_size
);
1443 if (class->exception_type
)
1445 mono_class_layout_fields (class);
1447 /*valuetypes can't be neither bigger than 1Mb or empty. */
1448 if (class->valuetype
&& (class->instance_size
<= 0 || class->instance_size
> (0x100000 + sizeof (MonoObject
))))
1449 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, NULL
);
1453 * mono_class_setup_fields_locking:
1454 * @class: The class to initialize
1456 * Initializes the class->fields array of fields.
1457 * Aquires the loader lock.
1460 mono_class_setup_fields_locking (MonoClass
*class)
1462 mono_loader_lock ();
1463 mono_class_setup_fields (class);
1464 mono_loader_unlock ();
1468 * mono_class_has_references:
1470 * Returns whenever @klass->has_references is set, initializing it if needed.
1471 * Aquires the loader lock.
1474 mono_class_has_references (MonoClass
*klass
)
1476 if (klass
->init_pending
) {
1477 /* Be conservative */
1480 mono_class_init (klass
);
1482 return klass
->has_references
;
1486 /* useful until we keep track of gc-references in corlib etc. */
1488 #define IS_GC_REFERENCE(t) FALSE
1490 #define IS_GC_REFERENCE(t) ((t)->type == MONO_TYPE_U && class->image == mono_defaults.corlib)
1494 * mono_type_get_basic_type_from_generic:
1497 * Returns a closed type corresponding to the possibly open type
1501 mono_type_get_basic_type_from_generic (MonoType
*type
)
1503 /* When we do generic sharing we let type variables stand for reference types. */
1504 if (!type
->byref
&& (type
->type
== MONO_TYPE_VAR
|| type
->type
== MONO_TYPE_MVAR
))
1505 return &mono_defaults
.object_class
->byval_arg
;
1510 * mono_class_layout_fields:
1513 * Compute the placement of fields inside an object or struct, according to
1514 * the layout rules and set the following fields in @class:
1515 * - has_references (if the class contains instance references firled or structs that contain references)
1516 * - has_static_refs (same, but for static fields)
1517 * - instance_size (size of the object in memory)
1518 * - class_size (size needed for the static fields)
1519 * - size_inited (flag set when the instance_size is set)
1521 * LOCKING: this is supposed to be called with the loader lock held.
1524 mono_class_layout_fields (MonoClass
*class)
1527 const int top
= class->field
.count
;
1528 guint32 layout
= class->flags
& TYPE_ATTRIBUTE_LAYOUT_MASK
;
1529 guint32 pass
, passes
, real_size
;
1530 gboolean gc_aware_layout
= FALSE
;
1531 MonoClassField
*field
;
1534 * When we do generic sharing we need to have layout
1535 * information for open generic classes (either with a generic
1536 * context containing type variables or with a generic
1537 * container), so we don't return in that case anymore.
1541 * Enable GC aware auto layout: in this mode, reference
1542 * fields are grouped together inside objects, increasing collector
1544 * Requires that all classes whose layout is known to native code be annotated
1545 * with [StructLayout (LayoutKind.Sequential)]
1546 * Value types have gc_aware_layout disabled by default, as per
1547 * what the default is for other runtimes.
1549 /* corlib is missing [StructLayout] directives in many places */
1550 if (layout
== TYPE_ATTRIBUTE_AUTO_LAYOUT
) {
1551 if (class->image
!= mono_defaults
.corlib
&&
1552 class->byval_arg
.type
!= MONO_TYPE_VALUETYPE
)
1553 gc_aware_layout
= TRUE
;
1554 /* from System.dll, used in metadata/process.h */
1555 if (strcmp (class->name
, "ProcessStartInfo") == 0)
1556 gc_aware_layout
= FALSE
;
1559 /* Compute klass->has_references */
1561 * Process non-static fields first, since static fields might recursively
1562 * refer to the class itself.
1564 for (i
= 0; i
< top
; i
++) {
1567 field
= &class->fields
[i
];
1569 if (!(field
->type
->attrs
& FIELD_ATTRIBUTE_STATIC
)) {
1570 ftype
= mono_type_get_underlying_type (field
->type
);
1571 ftype
= mono_type_get_basic_type_from_generic (ftype
);
1572 if (MONO_TYPE_IS_REFERENCE (ftype
) || IS_GC_REFERENCE (ftype
) || ((MONO_TYPE_ISSTRUCT (ftype
) && mono_class_has_references (mono_class_from_mono_type (ftype
)))))
1573 class->has_references
= TRUE
;
1577 for (i
= 0; i
< top
; i
++) {
1580 field
= &class->fields
[i
];
1582 if (field
->type
->attrs
& FIELD_ATTRIBUTE_STATIC
) {
1583 ftype
= mono_type_get_underlying_type (field
->type
);
1584 ftype
= mono_type_get_basic_type_from_generic (ftype
);
1585 if (MONO_TYPE_IS_REFERENCE (ftype
) || IS_GC_REFERENCE (ftype
) || ((MONO_TYPE_ISSTRUCT (ftype
) && mono_class_has_references (mono_class_from_mono_type (ftype
)))))
1586 class->has_static_refs
= TRUE
;
1590 for (i
= 0; i
< top
; i
++) {
1593 field
= &class->fields
[i
];
1595 ftype
= mono_type_get_underlying_type (field
->type
);
1596 ftype
= mono_type_get_basic_type_from_generic (ftype
);
1597 if (MONO_TYPE_IS_REFERENCE (ftype
) || IS_GC_REFERENCE (ftype
) || ((MONO_TYPE_ISSTRUCT (ftype
) && mono_class_has_references (mono_class_from_mono_type (ftype
))))) {
1598 if (field
->type
->attrs
& FIELD_ATTRIBUTE_STATIC
)
1599 class->has_static_refs
= TRUE
;
1601 class->has_references
= TRUE
;
1606 * Compute field layout and total size (not considering static fields)
1610 case TYPE_ATTRIBUTE_AUTO_LAYOUT
:
1611 case TYPE_ATTRIBUTE_SEQUENTIAL_LAYOUT
:
1613 if (gc_aware_layout
)
1618 if (layout
!= TYPE_ATTRIBUTE_AUTO_LAYOUT
)
1622 real_size
= class->parent
->instance_size
;
1624 real_size
= sizeof (MonoObject
);
1626 for (pass
= 0; pass
< passes
; ++pass
) {
1627 for (i
= 0; i
< top
; i
++){
1632 field
= &class->fields
[i
];
1634 if (mono_field_is_deleted (field
))
1636 if (field
->type
->attrs
& FIELD_ATTRIBUTE_STATIC
)
1639 ftype
= mono_type_get_underlying_type (field
->type
);
1640 ftype
= mono_type_get_basic_type_from_generic (ftype
);
1641 if (gc_aware_layout
) {
1642 if (MONO_TYPE_IS_REFERENCE (ftype
) || IS_GC_REFERENCE (ftype
) || ((MONO_TYPE_ISSTRUCT (ftype
) && mono_class_has_references (mono_class_from_mono_type (ftype
))))) {
1651 if ((top
== 1) && (class->instance_size
== sizeof (MonoObject
)) &&
1652 (strcmp (mono_field_get_name (field
), "$PRIVATE$") == 0)) {
1653 /* This field is a hack inserted by MCS to empty structures */
1657 size
= mono_type_size (field
->type
, &align
);
1659 /* FIXME (LAMESPEC): should we also change the min alignment according to pack? */
1660 align
= class->packing_size
? MIN (class->packing_size
, align
): align
;
1661 /* if the field has managed references, we need to force-align it
1664 if (MONO_TYPE_IS_REFERENCE (ftype
) || IS_GC_REFERENCE (ftype
) || ((MONO_TYPE_ISSTRUCT (ftype
) && mono_class_has_references (mono_class_from_mono_type (ftype
)))))
1665 align
= MAX (align
, sizeof (gpointer
));
1667 class->min_align
= MAX (align
, class->min_align
);
1668 field
->offset
= real_size
;
1670 field
->offset
+= align
- 1;
1671 field
->offset
&= ~(align
- 1);
1673 /*TypeBuilders produce all sort of weird things*/
1674 g_assert (class->image
->dynamic
|| field
->offset
> 0);
1675 real_size
= field
->offset
+ size
;
1678 class->instance_size
= MAX (real_size
, class->instance_size
);
1680 if (class->instance_size
& (class->min_align
- 1)) {
1681 class->instance_size
+= class->min_align
- 1;
1682 class->instance_size
&= ~(class->min_align
- 1);
1686 case TYPE_ATTRIBUTE_EXPLICIT_LAYOUT
:
1688 for (i
= 0; i
< top
; i
++) {
1693 field
= &class->fields
[i
];
1696 * There must be info about all the fields in a type if it
1697 * uses explicit layout.
1700 if (mono_field_is_deleted (field
))
1702 if (field
->type
->attrs
& FIELD_ATTRIBUTE_STATIC
)
1705 size
= mono_type_size (field
->type
, &align
);
1706 class->min_align
= MAX (align
, class->min_align
);
1709 * When we get here, field->offset is already set by the
1710 * loader (for either runtime fields or fields loaded from metadata).
1711 * The offset is from the start of the object: this works for both
1712 * classes and valuetypes.
1714 field
->offset
+= sizeof (MonoObject
);
1715 ftype
= mono_type_get_underlying_type (field
->type
);
1716 ftype
= mono_type_get_basic_type_from_generic (ftype
);
1717 if (MONO_TYPE_IS_REFERENCE (ftype
) || ((MONO_TYPE_ISSTRUCT (ftype
) && mono_class_has_references (mono_class_from_mono_type (ftype
))))) {
1718 if (field
->offset
% sizeof (gpointer
)) {
1719 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, NULL
);
1726 real_size
= MAX (real_size
, size
+ field
->offset
);
1728 class->instance_size
= MAX (real_size
, class->instance_size
);
1732 if (layout
!= TYPE_ATTRIBUTE_EXPLICIT_LAYOUT
) {
1734 * For small structs, set min_align to at least the struct size to improve
1735 * performance, and since the JIT memset/memcpy code assumes this and generates
1736 * unaligned accesses otherwise. See #78990 for a testcase.
1738 if (class->instance_size
<= sizeof (MonoObject
) + sizeof (gpointer
))
1739 class->min_align
= MAX (class->min_align
, class->instance_size
- sizeof (MonoObject
));
1742 class->size_inited
= 1;
1745 * Compute static field layout and size
1747 for (i
= 0; i
< top
; i
++){
1751 field
= &class->fields
[i
];
1753 if (!(field
->type
->attrs
& FIELD_ATTRIBUTE_STATIC
) || field
->type
->attrs
& FIELD_ATTRIBUTE_LITERAL
)
1755 if (mono_field_is_deleted (field
))
1758 if (mono_type_has_exceptions (field
->type
)) {
1759 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, NULL
);
1763 size
= mono_type_size (field
->type
, &align
);
1764 field
->offset
= class->sizes
.class_size
;
1765 /*align is always non-zero here*/
1766 field
->offset
+= align
- 1;
1767 field
->offset
&= ~(align
- 1);
1768 class->sizes
.class_size
= field
->offset
+ size
;
1773 create_array_method (MonoClass
*class, const char *name
, MonoMethodSignature
*sig
)
1777 method
= (MonoMethod
*) mono_image_alloc0 (class->image
, sizeof (MonoMethodPInvoke
));
1778 method
->klass
= class;
1779 method
->flags
= METHOD_ATTRIBUTE_PUBLIC
;
1780 method
->iflags
= METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL
;
1781 method
->signature
= sig
;
1782 method
->name
= name
;
1785 if (name
[0] == '.') {
1786 method
->flags
|= METHOD_ATTRIBUTE_RT_SPECIAL_NAME
| METHOD_ATTRIBUTE_SPECIAL_NAME
;
1788 method
->iflags
|= METHOD_IMPL_ATTRIBUTE_RUNTIME
;
1794 * mono_class_setup_methods:
1797 * Initializes the 'methods' array in the klass.
1798 * Calling this method should be avoided if possible since it allocates a lot
1799 * of long-living MonoMethod structures.
1800 * Methods belonging to an interface are assigned a sequential slot starting
1803 * On failure this function sets class->exception_type
1806 mono_class_setup_methods (MonoClass
*class)
1809 MonoMethod
**methods
;
1814 mono_loader_lock ();
1816 if (class->methods
) {
1817 mono_loader_unlock ();
1821 if (class->generic_class
) {
1823 MonoClass
*gklass
= class->generic_class
->container_class
;
1825 mono_class_init (gklass
);
1826 if (!gklass
->exception_type
)
1827 mono_class_setup_methods (gklass
);
1828 if (gklass
->exception_type
) {
1829 /*FIXME make exception_data less opaque so it's possible to dup it here*/
1830 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, g_strdup ("Generic type definition failed to load"));
1831 mono_loader_unlock ();
1835 /* The + 1 makes this always non-NULL to pass the check in mono_class_setup_methods () */
1836 class->method
.count
= gklass
->method
.count
;
1837 methods
= mono_class_alloc0 (class, sizeof (MonoMethod
*) * (class->method
.count
+ 1));
1839 for (i
= 0; i
< class->method
.count
; i
++) {
1840 methods
[i
] = mono_class_inflate_generic_method_full_checked (
1841 gklass
->methods
[i
], class, mono_class_get_context (class), &error
);
1842 if (!mono_error_ok (&error
)) {
1843 char *method
= mono_method_full_name (gklass
->methods
[i
], TRUE
);
1844 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
)));
1847 mono_error_cleanup (&error
);
1848 mono_loader_unlock ();
1852 } else if (class->rank
) {
1854 MonoMethod
*amethod
;
1855 MonoMethodSignature
*sig
;
1856 int count_generic
= 0, first_generic
= 0;
1859 class->method
.count
= 3 + (class->rank
> 1? 2: 1);
1861 mono_class_setup_interfaces (class, &error
);
1862 g_assert (mono_error_ok (&error
)); /*FIXME can this fail for array types?*/
1864 if (class->interface_count
) {
1865 count_generic
= generic_array_methods (class);
1866 first_generic
= class->method
.count
;
1867 class->method
.count
+= class->interface_count
* count_generic
;
1870 methods
= mono_class_alloc0 (class, sizeof (MonoMethod
*) * class->method
.count
);
1872 sig
= mono_metadata_signature_alloc (class->image
, class->rank
);
1873 sig
->ret
= &mono_defaults
.void_class
->byval_arg
;
1874 sig
->pinvoke
= TRUE
;
1875 sig
->hasthis
= TRUE
;
1876 for (i
= 0; i
< class->rank
; ++i
)
1877 sig
->params
[i
] = &mono_defaults
.int32_class
->byval_arg
;
1879 amethod
= create_array_method (class, ".ctor", sig
);
1880 methods
[method_num
++] = amethod
;
1881 if (class->rank
> 1) {
1882 sig
= mono_metadata_signature_alloc (class->image
, class->rank
* 2);
1883 sig
->ret
= &mono_defaults
.void_class
->byval_arg
;
1884 sig
->pinvoke
= TRUE
;
1885 sig
->hasthis
= TRUE
;
1886 for (i
= 0; i
< class->rank
* 2; ++i
)
1887 sig
->params
[i
] = &mono_defaults
.int32_class
->byval_arg
;
1889 amethod
= create_array_method (class, ".ctor", sig
);
1890 methods
[method_num
++] = amethod
;
1892 /* element Get (idx11, [idx2, ...]) */
1893 sig
= mono_metadata_signature_alloc (class->image
, class->rank
);
1894 sig
->ret
= &class->element_class
->byval_arg
;
1895 sig
->pinvoke
= TRUE
;
1896 sig
->hasthis
= TRUE
;
1897 for (i
= 0; i
< class->rank
; ++i
)
1898 sig
->params
[i
] = &mono_defaults
.int32_class
->byval_arg
;
1899 amethod
= create_array_method (class, "Get", sig
);
1900 methods
[method_num
++] = amethod
;
1901 /* element& Address (idx11, [idx2, ...]) */
1902 sig
= mono_metadata_signature_alloc (class->image
, class->rank
);
1903 sig
->ret
= &class->element_class
->this_arg
;
1904 sig
->pinvoke
= TRUE
;
1905 sig
->hasthis
= TRUE
;
1906 for (i
= 0; i
< class->rank
; ++i
)
1907 sig
->params
[i
] = &mono_defaults
.int32_class
->byval_arg
;
1908 amethod
= create_array_method (class, "Address", sig
);
1909 methods
[method_num
++] = amethod
;
1910 /* void Set (idx11, [idx2, ...], element) */
1911 sig
= mono_metadata_signature_alloc (class->image
, class->rank
+ 1);
1912 sig
->ret
= &mono_defaults
.void_class
->byval_arg
;
1913 sig
->pinvoke
= TRUE
;
1914 sig
->hasthis
= TRUE
;
1915 for (i
= 0; i
< class->rank
; ++i
)
1916 sig
->params
[i
] = &mono_defaults
.int32_class
->byval_arg
;
1917 sig
->params
[i
] = &class->element_class
->byval_arg
;
1918 amethod
= create_array_method (class, "Set", sig
);
1919 methods
[method_num
++] = amethod
;
1921 for (i
= 0; i
< class->interface_count
; i
++)
1922 setup_generic_array_ifaces (class, class->interfaces
[i
], methods
, first_generic
+ i
* count_generic
);
1924 methods
= mono_class_alloc (class, sizeof (MonoMethod
*) * class->method
.count
);
1925 for (i
= 0; i
< class->method
.count
; ++i
) {
1926 int idx
= mono_metadata_translate_token_index (class->image
, MONO_TABLE_METHOD
, class->method
.first
+ i
+ 1);
1927 methods
[i
] = mono_get_method (class->image
, MONO_TOKEN_METHOD_DEF
| idx
, class);
1931 if (MONO_CLASS_IS_INTERFACE (class)) {
1933 /*Only assign slots to virtual methods as interfaces are allowed to have static methods.*/
1934 for (i
= 0; i
< class->method
.count
; ++i
) {
1935 if (methods
[i
]->flags
& METHOD_ATTRIBUTE_VIRTUAL
)
1936 methods
[i
]->slot
= slot
++;
1940 /* Needed because of the double-checking locking pattern */
1941 mono_memory_barrier ();
1943 class->methods
= methods
;
1945 if (mono_debugger_class_loaded_methods_func
)
1946 mono_debugger_class_loaded_methods_func (class);
1948 mono_loader_unlock ();
1952 * mono_class_get_method_by_index:
1954 * Returns class->methods [index], initializing class->methods if neccesary.
1956 * LOCKING: Acquires the loader lock.
1959 mono_class_get_method_by_index (MonoClass
*class, int index
)
1961 /* Avoid calling setup_methods () if possible */
1962 if (class->generic_class
&& !class->methods
) {
1963 MonoClass
*gklass
= class->generic_class
->container_class
;
1966 m
= mono_class_inflate_generic_method_full (
1967 gklass
->methods
[index
], class, mono_class_get_context (class));
1969 * If setup_methods () is called later for this class, no duplicates are created,
1970 * since inflate_generic_method guarantees that only one instance of a method
1971 * is created for each context.
1974 mono_class_setup_methods (class);
1975 g_assert (m == class->methods [index]);
1979 mono_class_setup_methods (class);
1980 if (class->exception_type
) /*FIXME do proper error handling*/
1982 g_assert (index
>= 0 && index
< class->method
.count
);
1983 return class->methods
[index
];
1988 * mono_class_get_inflated_method:
1990 * Given an inflated class CLASS and a method METHOD which should be a method of
1991 * CLASS's generic definition, return the inflated method corresponding to METHOD.
1994 mono_class_get_inflated_method (MonoClass
*class, MonoMethod
*method
)
1996 MonoClass
*gklass
= class->generic_class
->container_class
;
1999 g_assert (method
->klass
== gklass
);
2001 mono_class_setup_methods (gklass
);
2002 g_assert (!gklass
->exception_type
); /*FIXME do proper error handling*/
2004 for (i
= 0; i
< gklass
->method
.count
; ++i
) {
2005 if (gklass
->methods
[i
] == method
) {
2007 return class->methods
[i
];
2009 return mono_class_inflate_generic_method_full (gklass
->methods
[i
], class, mono_class_get_context (class));
2017 * mono_class_get_vtable_entry:
2019 * Returns class->vtable [offset], computing it if neccesary.
2020 * LOCKING: Acquires the loader lock.
2023 mono_class_get_vtable_entry (MonoClass
*class, int offset
)
2027 if (class->rank
== 1) {
2029 * szarrays do not overwrite any methods of Array, so we can avoid
2030 * initializing their vtables in some cases.
2032 mono_class_setup_vtable (class->parent
);
2033 if (offset
< class->parent
->vtable_size
)
2034 return class->parent
->vtable
[offset
];
2037 if (class->generic_class
) {
2038 MonoClass
*gklass
= class->generic_class
->container_class
;
2039 mono_class_setup_vtable (gklass
);
2040 m
= gklass
->vtable
[offset
];
2042 m
= mono_class_inflate_generic_method_full (m
, class, mono_class_get_context (class));
2044 mono_class_setup_vtable (class);
2045 m
= class->vtable
[offset
];
2052 * mono_class_get_vtable_size:
2054 * Return the vtable size for KLASS.
2057 mono_class_get_vtable_size (MonoClass
*klass
)
2059 mono_class_setup_vtable (klass
);
2061 return klass
->vtable_size
;
2064 /*This method can fail the class.*/
2066 mono_class_setup_properties (MonoClass
*class)
2068 guint startm
, endm
, i
, j
;
2069 guint32 cols
[MONO_PROPERTY_SIZE
];
2070 MonoTableInfo
*msemt
= &class->image
->tables
[MONO_TABLE_METHODSEMANTICS
];
2071 MonoProperty
*properties
;
2074 if (class->ext
&& class->ext
->properties
)
2077 mono_loader_lock ();
2079 if (class->ext
&& class->ext
->properties
) {
2080 mono_loader_unlock ();
2084 mono_class_alloc_ext (class);
2086 if (class->generic_class
) {
2087 MonoClass
*gklass
= class->generic_class
->container_class
;
2089 mono_class_init (gklass
);
2090 mono_class_setup_properties (gklass
);
2091 if (gklass
->exception_type
) {
2092 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, g_strdup ("Generic type definition failed to load"));
2093 mono_loader_unlock ();
2097 class->ext
->property
= gklass
->ext
->property
;
2099 properties
= mono_class_new0 (class, MonoProperty
, class->ext
->property
.count
+ 1);
2101 for (i
= 0; i
< class->ext
->property
.count
; i
++) {
2102 MonoProperty
*prop
= &properties
[i
];
2104 *prop
= gklass
->ext
->properties
[i
];
2107 prop
->get
= mono_class_inflate_generic_method_full (
2108 prop
->get
, class, mono_class_get_context (class));
2110 prop
->set
= mono_class_inflate_generic_method_full (
2111 prop
->set
, class, mono_class_get_context (class));
2113 prop
->parent
= class;
2116 int first
= mono_metadata_properties_from_typedef (class->image
, mono_metadata_token_index (class->type_token
) - 1, &last
);
2117 int count
= last
- first
;
2120 mono_class_setup_methods (class);
2121 if (class->exception_type
) {
2122 mono_loader_unlock ();
2127 class->ext
->property
.first
= first
;
2128 class->ext
->property
.count
= count
;
2129 properties
= mono_class_alloc0 (class, sizeof (MonoProperty
) * count
);
2130 for (i
= first
; i
< last
; ++i
) {
2131 mono_metadata_decode_table_row (class->image
, MONO_TABLE_PROPERTY
, i
, cols
, MONO_PROPERTY_SIZE
);
2132 properties
[i
- first
].parent
= class;
2133 properties
[i
- first
].attrs
= cols
[MONO_PROPERTY_FLAGS
];
2134 properties
[i
- first
].name
= mono_metadata_string_heap (class->image
, cols
[MONO_PROPERTY_NAME
]);
2136 startm
= mono_metadata_methods_from_property (class->image
, i
, &endm
);
2137 for (j
= startm
; j
< endm
; ++j
) {
2140 mono_metadata_decode_row (msemt
, j
, cols
, MONO_METHOD_SEMA_SIZE
);
2142 if (class->image
->uncompressed_metadata
)
2143 /* It seems like the MONO_METHOD_SEMA_METHOD column needs no remapping */
2144 method
= mono_get_method (class->image
, MONO_TOKEN_METHOD_DEF
| cols
[MONO_METHOD_SEMA_METHOD
], class);
2146 method
= class->methods
[cols
[MONO_METHOD_SEMA_METHOD
] - 1 - class->method
.first
];
2148 switch (cols
[MONO_METHOD_SEMA_SEMANTICS
]) {
2149 case METHOD_SEMANTIC_SETTER
:
2150 properties
[i
- first
].set
= method
;
2152 case METHOD_SEMANTIC_GETTER
:
2153 properties
[i
- first
].get
= method
;
2161 /*Flush any pending writes as we do double checked locking on class->properties */
2162 mono_memory_barrier ();
2164 /* Leave this assignment as the last op in the function */
2165 class->ext
->properties
= properties
;
2167 mono_loader_unlock ();
2171 inflate_method_listz (MonoMethod
**methods
, MonoClass
*class, MonoGenericContext
*context
)
2173 MonoMethod
**om
, **retval
;
2176 for (om
= methods
, count
= 0; *om
; ++om
, ++count
)
2179 retval
= g_new0 (MonoMethod
*, count
+ 1);
2181 for (om
= methods
, count
= 0; *om
; ++om
, ++count
)
2182 retval
[count
] = mono_class_inflate_generic_method_full (*om
, class, context
);
2187 /*This method can fail the class.*/
2189 mono_class_setup_events (MonoClass
*class)
2192 guint startm
, endm
, i
, j
;
2193 guint32 cols
[MONO_EVENT_SIZE
];
2194 MonoTableInfo
*msemt
= &class->image
->tables
[MONO_TABLE_METHODSEMANTICS
];
2198 if (class->ext
&& class->ext
->events
)
2201 mono_loader_lock ();
2203 if (class->ext
&& class->ext
->events
) {
2204 mono_loader_unlock ();
2208 mono_class_alloc_ext (class);
2210 if (class->generic_class
) {
2211 MonoClass
*gklass
= class->generic_class
->container_class
;
2212 MonoGenericContext
*context
;
2214 mono_class_setup_events (gklass
);
2215 if (gklass
->exception_type
) {
2216 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, g_strdup ("Generic type definition failed to load"));
2217 mono_loader_unlock ();
2221 class->ext
->event
= gklass
->ext
->event
;
2222 class->ext
->events
= mono_class_new0 (class, MonoEvent
, class->ext
->event
.count
);
2224 if (class->ext
->event
.count
)
2225 context
= mono_class_get_context (class);
2227 for (i
= 0; i
< class->ext
->event
.count
; i
++) {
2228 MonoEvent
*event
= &class->ext
->events
[i
];
2229 MonoEvent
*gevent
= &gklass
->ext
->events
[i
];
2231 event
->parent
= class;
2232 event
->name
= gevent
->name
;
2233 event
->add
= gevent
->add
? mono_class_inflate_generic_method_full (gevent
->add
, class, context
) : NULL
;
2234 event
->remove
= gevent
->remove
? mono_class_inflate_generic_method_full (gevent
->remove
, class, context
) : NULL
;
2235 event
->raise
= gevent
->raise
? mono_class_inflate_generic_method_full (gevent
->raise
, class, context
) : NULL
;
2236 #ifndef MONO_SMALL_CONFIG
2237 event
->other
= gevent
->other
? inflate_method_listz (gevent
->other
, class, context
) : NULL
;
2239 event
->attrs
= gevent
->attrs
;
2242 mono_loader_unlock ();
2246 first
= mono_metadata_events_from_typedef (class->image
, mono_metadata_token_index (class->type_token
) - 1, &last
);
2247 count
= last
- first
;
2250 mono_class_setup_methods (class);
2251 if (class->exception_type
) {
2252 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, g_strdup ("Generic type definition failed to load"));
2253 mono_loader_unlock ();
2257 class->ext
->event
.first
= first
;
2258 class->ext
->event
.count
= count
;
2259 events
= mono_class_alloc0 (class, sizeof (MonoEvent
) * class->ext
->event
.count
);
2260 for (i
= first
; i
< last
; ++i
) {
2261 MonoEvent
*event
= &events
[i
- first
];
2263 mono_metadata_decode_table_row (class->image
, MONO_TABLE_EVENT
, i
, cols
, MONO_EVENT_SIZE
);
2264 event
->parent
= class;
2265 event
->attrs
= cols
[MONO_EVENT_FLAGS
];
2266 event
->name
= mono_metadata_string_heap (class->image
, cols
[MONO_EVENT_NAME
]);
2268 startm
= mono_metadata_methods_from_event (class->image
, i
, &endm
);
2269 for (j
= startm
; j
< endm
; ++j
) {
2272 mono_metadata_decode_row (msemt
, j
, cols
, MONO_METHOD_SEMA_SIZE
);
2274 if (class->image
->uncompressed_metadata
)
2275 /* It seems like the MONO_METHOD_SEMA_METHOD column needs no remapping */
2276 method
= mono_get_method (class->image
, MONO_TOKEN_METHOD_DEF
| cols
[MONO_METHOD_SEMA_METHOD
], class);
2278 method
= class->methods
[cols
[MONO_METHOD_SEMA_METHOD
] - 1 - class->method
.first
];
2280 switch (cols
[MONO_METHOD_SEMA_SEMANTICS
]) {
2281 case METHOD_SEMANTIC_ADD_ON
:
2282 event
->add
= method
;
2284 case METHOD_SEMANTIC_REMOVE_ON
:
2285 event
->remove
= method
;
2287 case METHOD_SEMANTIC_FIRE
:
2288 event
->raise
= method
;
2290 case METHOD_SEMANTIC_OTHER
: {
2291 #ifndef MONO_SMALL_CONFIG
2294 if (event
->other
== NULL
) {
2295 event
->other
= g_new0 (MonoMethod
*, 2);
2297 while (event
->other
[n
])
2299 event
->other
= g_realloc (event
->other
, (n
+ 2) * sizeof (MonoMethod
*));
2301 event
->other
[n
] = method
;
2302 /* NULL terminated */
2303 event
->other
[n
+ 1] = NULL
;
2312 /*Flush any pending writes as we do double checked locking on class->properties */
2313 mono_memory_barrier ();
2315 /* Leave this assignment as the last op in the function */
2316 class->ext
->events
= events
;
2318 mono_loader_unlock ();
2322 * Global pool of interface IDs, represented as a bitset.
2323 * LOCKING: this is supposed to be accessed with the loader lock held.
2325 static MonoBitSet
*global_interface_bitset
= NULL
;
2328 * mono_unload_interface_ids:
2329 * @bitset: bit set of interface IDs
2331 * When an image is unloaded, the interface IDs associated with
2332 * the image are put back in the global pool of IDs so the numbers
2336 mono_unload_interface_ids (MonoBitSet
*bitset
)
2338 mono_loader_lock ();
2339 mono_bitset_sub (global_interface_bitset
, bitset
);
2340 mono_loader_unlock ();
2344 * mono_get_unique_iid:
2347 * Assign a unique integer ID to the interface represented by @class.
2348 * The ID will positive and as small as possible.
2349 * LOCKING: this is supposed to be called with the loader lock held.
2350 * Returns: the new ID.
2353 mono_get_unique_iid (MonoClass
*class)
2357 g_assert (MONO_CLASS_IS_INTERFACE (class));
2359 if (!global_interface_bitset
) {
2360 global_interface_bitset
= mono_bitset_new (128, 0);
2363 iid
= mono_bitset_find_first_unset (global_interface_bitset
, -1);
2365 int old_size
= mono_bitset_size (global_interface_bitset
);
2366 MonoBitSet
*new_set
= mono_bitset_clone (global_interface_bitset
, old_size
* 2);
2367 mono_bitset_free (global_interface_bitset
);
2368 global_interface_bitset
= new_set
;
2371 mono_bitset_set (global_interface_bitset
, iid
);
2372 /* set the bit also in the per-image set */
2373 if (class->image
->interface_bitset
) {
2374 if (iid
>= mono_bitset_size (class->image
->interface_bitset
)) {
2375 MonoBitSet
*new_set
= mono_bitset_clone (class->image
->interface_bitset
, iid
+ 1);
2376 mono_bitset_free (class->image
->interface_bitset
);
2377 class->image
->interface_bitset
= new_set
;
2380 class->image
->interface_bitset
= mono_bitset_new (iid
+ 1, 0);
2382 mono_bitset_set (class->image
->interface_bitset
, iid
);
2384 #ifndef MONO_SMALL_CONFIG
2385 if (mono_print_vtable
) {
2387 char *type_name
= mono_type_full_name (&class->byval_arg
);
2388 if (class->generic_class
&& !class->generic_class
->context
.class_inst
->is_open
) {
2389 generic_id
= class->generic_class
->context
.class_inst
->id
;
2390 g_assert (generic_id
!= 0);
2394 printf ("Interface: assigned id %d to %s|%s|%d\n", iid
, class->image
->name
, type_name
, generic_id
);
2399 g_assert (iid
<= 65535);
2404 collect_implemented_interfaces_aux (MonoClass
*klass
, GPtrArray
**res
, MonoError
*error
)
2409 mono_class_setup_interfaces (klass
, error
);
2410 if (!mono_error_ok (error
))
2413 for (i
= 0; i
< klass
->interface_count
; i
++) {
2414 ic
= klass
->interfaces
[i
];
2417 *res
= g_ptr_array_new ();
2418 g_ptr_array_add (*res
, ic
);
2419 mono_class_init (ic
);
2421 collect_implemented_interfaces_aux (ic
, res
, error
);
2422 if (!mono_error_ok (error
))
2428 mono_class_get_implemented_interfaces (MonoClass
*klass
, MonoError
*error
)
2430 GPtrArray
*res
= NULL
;
2432 collect_implemented_interfaces_aux (klass
, &res
, error
);
2433 if (!mono_error_ok (error
)) {
2435 g_ptr_array_free (res
, TRUE
);
2442 compare_interface_ids (const void *p_key
, const void *p_element
) {
2443 const MonoClass
*key
= p_key
;
2444 const MonoClass
*element
= *(MonoClass
**) p_element
;
2446 return (key
->interface_id
- element
->interface_id
);
2449 /*FIXME verify all callers if they should switch to mono_class_interface_offset_with_variance*/
2451 mono_class_interface_offset (MonoClass
*klass
, MonoClass
*itf
) {
2452 MonoClass
**result
= bsearch (
2454 klass
->interfaces_packed
,
2455 klass
->interface_offsets_count
,
2456 sizeof (MonoClass
*),
2457 compare_interface_ids
);
2459 return klass
->interface_offsets_packed
[result
- (klass
->interfaces_packed
)];
2466 * mono_class_interface_offset_with_variance:
2468 * Return the interface offset of @itf in @klass. Sets @non_exact_match to TRUE if the match required variance check
2469 * If @itf is an interface with generic variant arguments, try to find the compatible one.
2471 * Note that this function is responsible for resolving ambiguities. Right now we use whatever ordering interfaces_packed gives us.
2473 * FIXME figure out MS disambiguation rules and fix this function.
2476 mono_class_interface_offset_with_variance (MonoClass
*klass
, MonoClass
*itf
, gboolean
*non_exact_match
) {
2477 int i
= mono_class_interface_offset (klass
, itf
);
2478 *non_exact_match
= FALSE
;
2482 if (!mono_class_has_variant_generic_params (itf
))
2485 for (i
= 0; i
< klass
->interface_offsets_count
; i
++) {
2486 if (mono_class_is_variant_compatible (itf
, klass
->interfaces_packed
[i
])) {
2487 *non_exact_match
= TRUE
;
2488 return klass
->interface_offsets_packed
[i
];
2496 print_implemented_interfaces (MonoClass
*klass
) {
2499 GPtrArray
*ifaces
= NULL
;
2501 int ancestor_level
= 0;
2503 name
= mono_type_get_full_name (klass
);
2504 printf ("Packed interface table for class %s has size %d\n", name
, klass
->interface_offsets_count
);
2507 for (i
= 0; i
< klass
->interface_offsets_count
; i
++)
2508 printf (" [%03d][UUID %03d][SLOT %03d][SIZE %03d] interface %s.%s\n", i
,
2509 klass
->interfaces_packed
[i
]->interface_id
,
2510 klass
->interface_offsets_packed
[i
],
2511 klass
->interfaces_packed
[i
]->method
.count
,
2512 klass
->interfaces_packed
[i
]->name_space
,
2513 klass
->interfaces_packed
[i
]->name
);
2514 printf ("Interface flags: ");
2515 for (i
= 0; i
<= klass
->max_interface_id
; i
++)
2516 if (MONO_CLASS_IMPLEMENTS_INTERFACE (klass
, i
))
2517 printf ("(%d,T)", i
);
2519 printf ("(%d,F)", i
);
2521 printf ("Dump interface flags:");
2522 #ifdef COMPRESSED_INTERFACE_BITMAP
2524 const uint8_t* p
= klass
->interface_bitmap
;
2525 i
= klass
->max_interface_id
;
2527 printf (" %d x 00 %02X", p
[0], p
[1]);
2533 for (i
= 0; i
< ((((klass
->max_interface_id
+ 1) >> 3)) + (((klass
->max_interface_id
+ 1) & 7)? 1 :0)); i
++)
2534 printf (" %02X", klass
->interface_bitmap
[i
]);
2537 while (klass
!= NULL
) {
2538 printf ("[LEVEL %d] Implemented interfaces by class %s:\n", ancestor_level
, klass
->name
);
2539 ifaces
= mono_class_get_implemented_interfaces (klass
, &error
);
2540 if (!mono_error_ok (&error
)) {
2541 printf (" Type failed due to %s\n", mono_error_get_message (&error
));
2542 mono_error_cleanup (&error
);
2543 } else if (ifaces
) {
2544 for (i
= 0; i
< ifaces
->len
; i
++) {
2545 MonoClass
*ic
= g_ptr_array_index (ifaces
, i
);
2546 printf (" [UIID %d] interface %s\n", ic
->interface_id
, ic
->name
);
2547 printf (" [%03d][UUID %03d][SLOT %03d][SIZE %03d] interface %s.%s\n", i
,
2549 mono_class_interface_offset (klass
, ic
),
2554 g_ptr_array_free (ifaces
, TRUE
);
2557 klass
= klass
->parent
;
2562 inflate_class_one_arg (MonoClass
*gtype
, MonoClass
*arg0
)
2565 args
[0] = &arg0
->byval_arg
;
2567 return mono_class_bind_generic_parameters (gtype
, 1, args
, FALSE
);
2571 array_class_get_if_rank (MonoClass
*class, guint rank
)
2573 return rank
? mono_array_class_get (class, rank
) : class;
2577 fill_valuetype_array_derived_types (MonoClass
**valuetype_types
, MonoClass
*eclass
, int rank
)
2579 valuetype_types
[0] = eclass
;
2580 if (eclass
== mono_defaults
.int16_class
)
2581 valuetype_types
[1] = mono_defaults
.uint16_class
;
2582 else if (eclass
== mono_defaults
.uint16_class
)
2583 valuetype_types
[1] = mono_defaults
.int16_class
;
2584 else if (eclass
== mono_defaults
.int32_class
)
2585 valuetype_types
[1] = mono_defaults
.uint32_class
;
2586 else if (eclass
== mono_defaults
.uint32_class
)
2587 valuetype_types
[1] = mono_defaults
.int32_class
;
2588 else if (eclass
== mono_defaults
.int64_class
)
2589 valuetype_types
[1] = mono_defaults
.uint64_class
;
2590 else if (eclass
== mono_defaults
.uint64_class
)
2591 valuetype_types
[1] = mono_defaults
.int64_class
;
2592 else if (eclass
== mono_defaults
.byte_class
)
2593 valuetype_types
[1] = mono_defaults
.sbyte_class
;
2594 else if (eclass
== mono_defaults
.sbyte_class
)
2595 valuetype_types
[1] = mono_defaults
.byte_class
;
2596 else if (eclass
->enumtype
&& mono_class_enum_basetype (eclass
))
2597 valuetype_types
[1] = mono_class_from_mono_type (mono_class_enum_basetype (eclass
));
2600 /* this won't be needed once bug #325495 is completely fixed
2601 * though we'll need something similar to know which interfaces to allow
2602 * in arrays when they'll be lazyly created
2604 * FIXME: System.Array/InternalEnumerator don't need all this interface fabrication machinery.
2605 * MS returns diferrent types based on which instance is called. For example:
2606 * object obj = new byte[10][];
2607 * Type a = ((IEnumerable<byte[]>)obj).GetEnumerator ().GetType ();
2608 * Type b = ((IEnumerable<IList<byte>>)obj).GetEnumerator ().GetType ();
2611 * Fixing this should kill quite some code, save some bits and improve compatibility.
2614 get_implicit_generic_array_interfaces (MonoClass
*class, int *num
, int *is_enumerator
)
2616 MonoClass
*eclass
= class->element_class
;
2617 static MonoClass
* generic_icollection_class
= NULL
;
2618 static MonoClass
* generic_ienumerable_class
= NULL
;
2619 static MonoClass
* generic_ienumerator_class
= NULL
;
2620 MonoClass
*valuetype_types
[2] = { NULL
, NULL
};
2621 MonoClass
**interfaces
= NULL
;
2622 int i
, interface_count
, real_count
, original_rank
;
2624 gboolean internal_enumerator
;
2625 gboolean eclass_is_valuetype
;
2627 if (!mono_defaults
.generic_ilist_class
) {
2631 internal_enumerator
= FALSE
;
2632 eclass_is_valuetype
= FALSE
;
2633 original_rank
= eclass
->rank
;
2634 if (class->byval_arg
.type
!= MONO_TYPE_SZARRAY
) {
2635 if (class->generic_class
&& class->nested_in
== mono_defaults
.array_class
&& strcmp (class->name
, "InternalEnumerator`1") == 0) {
2637 * For a Enumerator<T[]> we need to get the list of interfaces for T.
2639 eclass
= mono_class_from_mono_type (class->generic_class
->context
.class_inst
->type_argv
[0]);
2640 original_rank
= eclass
->rank
;
2641 eclass
= eclass
->element_class
;
2642 internal_enumerator
= TRUE
;
2643 *is_enumerator
= TRUE
;
2651 * with this non-lazy impl we can't implement all the interfaces so we do just the minimal stuff
2652 * for deep levels of arrays of arrays (string[][] has all the interfaces, string[][][] doesn't)
2654 all_interfaces
= eclass
->rank
&& eclass
->element_class
->rank
? FALSE
: TRUE
;
2656 if (!generic_icollection_class
) {
2657 generic_icollection_class
= mono_class_from_name (mono_defaults
.corlib
,
2658 "System.Collections.Generic", "ICollection`1");
2659 generic_ienumerable_class
= mono_class_from_name (mono_defaults
.corlib
,
2660 "System.Collections.Generic", "IEnumerable`1");
2661 generic_ienumerator_class
= mono_class_from_name (mono_defaults
.corlib
,
2662 "System.Collections.Generic", "IEnumerator`1");
2665 mono_class_init (eclass
);
2668 * Arrays in 2.0 need to implement a number of generic interfaces
2669 * (IList`1, ICollection`1, IEnumerable`1 for a number of types depending
2670 * on the element class). We collect the types needed to build the
2671 * instantiations in interfaces at intervals of 3, because 3 are
2672 * the generic interfaces needed to implement.
2674 if (eclass
->valuetype
) {
2675 fill_valuetype_array_derived_types (valuetype_types
, eclass
, original_rank
);
2677 /* IList, ICollection, IEnumerable */
2678 real_count
= interface_count
= valuetype_types
[1] ? 6 : 3;
2679 if (internal_enumerator
) {
2681 if (valuetype_types
[1])
2685 interfaces
= g_malloc0 (sizeof (MonoClass
*) * real_count
);
2686 interfaces
[0] = valuetype_types
[0];
2687 if (valuetype_types
[1])
2688 interfaces
[3] = valuetype_types
[1];
2690 eclass_is_valuetype
= TRUE
;
2693 int idepth
= eclass
->idepth
;
2694 if (!internal_enumerator
)
2697 // FIXME: This doesn't seem to work/required for generic params
2698 if (!(eclass
->this_arg
.type
== MONO_TYPE_VAR
|| eclass
->this_arg
.type
== MONO_TYPE_MVAR
|| (eclass
->image
->dynamic
&& !eclass
->wastypebuilder
)))
2699 mono_class_setup_interface_offsets (eclass
);
2701 interface_count
= all_interfaces
? eclass
->interface_offsets_count
: eclass
->interface_count
;
2702 /* we add object for interfaces and the supertypes for the other
2703 * types. The last of the supertypes is the element class itself which we
2704 * already created the explicit interfaces for (so we include it for IEnumerator
2705 * and exclude it for arrays).
2707 if (MONO_CLASS_IS_INTERFACE (eclass
))
2710 interface_count
+= idepth
;
2711 if (eclass
->rank
&& eclass
->element_class
->valuetype
) {
2712 fill_valuetype_array_derived_types (valuetype_types
, eclass
->element_class
, original_rank
);
2713 if (valuetype_types
[1])
2716 /* IList, ICollection, IEnumerable */
2717 interface_count
*= 3;
2718 real_count
= interface_count
;
2719 if (internal_enumerator
) {
2720 real_count
+= (MONO_CLASS_IS_INTERFACE (eclass
) ? 1 : idepth
) + eclass
->interface_offsets_count
;
2721 if (valuetype_types
[1])
2724 interfaces
= g_malloc0 (sizeof (MonoClass
*) * real_count
);
2725 if (MONO_CLASS_IS_INTERFACE (eclass
)) {
2726 interfaces
[0] = mono_defaults
.object_class
;
2730 for (i
= 0; i
< idepth
; i
++) {
2731 mono_class_init (eclass
->supertypes
[i
]);
2732 interfaces
[j
] = eclass
->supertypes
[i
];
2736 if (all_interfaces
) {
2737 for (i
= 0; i
< eclass
->interface_offsets_count
; i
++) {
2738 interfaces
[j
] = eclass
->interfaces_packed
[i
];
2742 for (i
= 0; i
< eclass
->interface_count
; i
++) {
2743 interfaces
[j
] = eclass
->interfaces
[i
];
2747 if (valuetype_types
[1]) {
2748 interfaces
[j
] = array_class_get_if_rank (valuetype_types
[1], original_rank
);
2753 /* instantiate the generic interfaces */
2754 for (i
= 0; i
< interface_count
; i
+= 3) {
2755 MonoClass
*iface
= interfaces
[i
];
2757 interfaces
[i
+ 0] = inflate_class_one_arg (mono_defaults
.generic_ilist_class
, iface
);
2758 interfaces
[i
+ 1] = inflate_class_one_arg (generic_icollection_class
, iface
);
2759 interfaces
[i
+ 2] = inflate_class_one_arg (generic_ienumerable_class
, iface
);
2761 if (internal_enumerator
) {
2763 /* instantiate IEnumerator<iface> */
2764 for (i
= 0; i
< interface_count
; i
++) {
2765 interfaces
[i
] = inflate_class_one_arg (generic_ienumerator_class
, interfaces
[i
]);
2767 j
= interface_count
;
2768 if (!eclass_is_valuetype
) {
2769 if (MONO_CLASS_IS_INTERFACE (eclass
)) {
2770 interfaces
[j
] = inflate_class_one_arg (generic_ienumerator_class
, mono_defaults
.object_class
);
2773 for (i
= 0; i
< eclass
->idepth
; i
++) {
2774 interfaces
[j
] = inflate_class_one_arg (generic_ienumerator_class
, eclass
->supertypes
[i
]);
2778 for (i
= 0; i
< eclass
->interface_offsets_count
; i
++) {
2779 interfaces
[j
] = inflate_class_one_arg (generic_ienumerator_class
, eclass
->interfaces_packed
[i
]);
2783 interfaces
[j
++] = inflate_class_one_arg (generic_ienumerator_class
, array_class_get_if_rank (valuetype_types
[0], original_rank
));
2785 if (valuetype_types
[1])
2786 interfaces
[j
] = inflate_class_one_arg (generic_ienumerator_class
, array_class_get_if_rank (valuetype_types
[1], original_rank
));
2790 char *type_name
= mono_type_get_name_full (&class->byval_arg
, 0);
2791 for (i
= 0; i
< real_count
; ++i
) {
2792 char *name
= mono_type_get_name_full (&interfaces
[i
]->byval_arg
, 0);
2793 g_print ("%s implements %s\n", type_name
, name
);
2804 find_array_interface (MonoClass
*klass
, const char *name
)
2807 for (i
= 0; i
< klass
->interface_count
; ++i
) {
2808 if (strcmp (klass
->interfaces
[i
]->name
, name
) == 0)
2815 * Return the number of virtual methods.
2816 * Even for interfaces we can't simply return the number of methods as all CLR types are allowed to have static methods.
2817 * Return -1 on failure.
2818 * FIXME It would be nice if this information could be cached somewhere.
2821 count_virtual_methods (MonoClass
*class)
2825 class = mono_class_get_generic_type_definition (class); /*We can find this information by looking at the GTD*/
2827 if (class->methods
|| !MONO_CLASS_HAS_STATIC_METADATA (class)) {
2828 mono_class_setup_methods (class);
2829 if (class->exception_type
)
2832 for (i
= 0; i
< class->method
.count
; ++i
) {
2833 flags
= class->methods
[i
]->flags
;
2834 if (flags
& METHOD_ATTRIBUTE_VIRTUAL
)
2838 for (i
= 0; i
< class->method
.count
; ++i
) {
2839 flags
= mono_metadata_decode_table_row_col (class->image
, MONO_TABLE_METHOD
, class->method
.first
+ i
, MONO_METHOD_FLAGS
);
2841 if (flags
& METHOD_ATTRIBUTE_VIRTUAL
)
2849 find_interface (int num_ifaces
, MonoClass
**interfaces_full
, MonoClass
*ic
)
2857 m
= (l
+ num_ifaces
) / 2;
2858 if (interfaces_full
[m
] == ic
)
2860 if (l
== num_ifaces
)
2862 if (!interfaces_full
[m
] || interfaces_full
[m
]->interface_id
> ic
->interface_id
) {
2871 find_interface_offset (int num_ifaces
, MonoClass
**interfaces_full
, int *interface_offsets_full
, MonoClass
*ic
)
2873 int i
= find_interface (num_ifaces
, interfaces_full
, ic
);
2875 return interface_offsets_full
[i
];
2880 set_interface_and_offset (int num_ifaces
, MonoClass
**interfaces_full
, int *interface_offsets_full
, MonoClass
*ic
, int offset
, mono_bool force_set
)
2882 int i
= find_interface (num_ifaces
, interfaces_full
, ic
);
2886 interface_offsets_full
[i
] = offset
;
2889 for (i
= 0; i
< num_ifaces
; ++i
) {
2890 if (interfaces_full
[i
]) {
2892 if (interfaces_full
[i
]->interface_id
< ic
->interface_id
)
2895 while (end
< num_ifaces
&& interfaces_full
[end
]) end
++;
2896 memmove (interfaces_full
+ i
+ 1, interfaces_full
+ i
, sizeof (MonoClass
*) * (end
- i
));
2897 memmove (interface_offsets_full
+ i
+ 1, interface_offsets_full
+ i
, sizeof (int) * (end
- i
));
2899 interfaces_full
[i
] = ic
;
2900 interface_offsets_full
[i
] = offset
;
2906 #ifdef COMPRESSED_INTERFACE_BITMAP
2909 * Compressed interface bitmap design.
2911 * Interface bitmaps take a large amount of memory, because their size is
2912 * linear with the maximum interface id assigned in the process (each interface
2913 * is assigned a unique id as it is loaded). The number of interface classes
2914 * is high because of the many implicit interfaces implemented by arrays (we'll
2915 * need to lazy-load them in the future).
2916 * Most classes implement a very small number of interfaces, so the bitmap is
2917 * sparse. This bitmap needs to be checked by interface casts, so access to the
2918 * needed bit must be fast and doable with few jit instructions.
2920 * The current compression format is as follows:
2921 * *) it is a sequence of one or more two-byte elements
2922 * *) the first byte in the element is the count of empty bitmap bytes
2923 * at the current bitmap position
2924 * *) the second byte in the element is an actual bitmap byte at the current
2927 * As an example, the following compressed bitmap bytes:
2928 * 0x07 0x01 0x00 0x7
2929 * correspond to the following bitmap:
2930 * 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x01 0x07
2932 * Each two-byte element can represent up to 2048 bitmap bits, but as few as a single
2933 * bitmap byte for non-sparse sequences. In practice the interface bitmaps created
2934 * during a gmcs bootstrap are reduced to less tha 5% of the original size.
2938 * mono_compress_bitmap:
2939 * @dest: destination buffer
2940 * @bitmap: bitmap buffer
2941 * @size: size of @bitmap in bytes
2943 * This is a mono internal function.
2944 * The @bitmap data is compressed into a format that is small but
2945 * still searchable in few instructions by the JIT and runtime.
2946 * The compressed data is stored in the buffer pointed to by the
2947 * @dest array. Passing a #NULL value for @dest allows to just compute
2948 * the size of the buffer.
2949 * This compression algorithm assumes the bits set in the bitmap are
2950 * few and far between, like in interface bitmaps.
2951 * Returns: the size of the compressed bitmap in bytes.
2954 mono_compress_bitmap (uint8_t *dest
, const uint8_t *bitmap
, int size
)
2958 const uint8_t *end
= bitmap
+ size
;
2959 while (bitmap
< end
) {
2960 if (*bitmap
|| numz
== 255) {
2984 * mono_class_interface_match:
2985 * @bitmap: a compressed bitmap buffer
2986 * @id: the index to check in the bitmap
2988 * This is a mono internal function.
2989 * Checks if a bit is set in a compressed interface bitmap. @id must
2990 * be already checked for being smaller than the maximum id encoded in the
2993 * Returns: a non-zero value if bit @id is set in the bitmap @bitmap,
2997 mono_class_interface_match (const uint8_t *bitmap
, int id
)
3000 id
-= bitmap
[0] * 8;
3004 return bitmap
[1] & (1 << id
);
3013 * LOCKING: this is supposed to be called with the loader lock held.
3014 * Return -1 on failure and set exception_type
3017 setup_interface_offsets (MonoClass
*class, int cur_slot
)
3021 int i
, j
, max_iid
, num_ifaces
;
3022 MonoClass
**interfaces_full
= NULL
;
3023 int *interface_offsets_full
= NULL
;
3025 GPtrArray
**ifaces_array
= NULL
;
3026 int interface_offsets_count
;
3027 MonoClass
**array_interfaces
= NULL
;
3028 int num_array_interfaces
;
3029 int is_enumerator
= FALSE
;
3031 mono_class_setup_supertypes (class);
3033 * get the implicit generic interfaces for either the arrays or for System.Array/InternalEnumerator<T>
3034 * implicit interfaces have the property that they are assigned the same slot in the
3035 * vtables for compatible interfaces
3037 array_interfaces
= get_implicit_generic_array_interfaces (class, &num_array_interfaces
, &is_enumerator
);
3039 /* compute maximum number of slots and maximum interface id */
3041 num_ifaces
= num_array_interfaces
; /* this can include duplicated ones */
3042 ifaces_array
= g_new0 (GPtrArray
*, class->idepth
);
3043 for (j
= 0; j
< class->idepth
; j
++) {
3044 k
= class->supertypes
[j
];
3045 num_ifaces
+= k
->interface_count
;
3046 for (i
= 0; i
< k
->interface_count
; i
++) {
3047 ic
= k
->interfaces
[i
];
3050 mono_class_init (ic
);
3052 if (max_iid
< ic
->interface_id
)
3053 max_iid
= ic
->interface_id
;
3055 ifaces
= mono_class_get_implemented_interfaces (k
, &error
);
3056 if (!mono_error_ok (&error
)) {
3057 char *name
= mono_type_get_full_name (k
);
3058 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
)));
3060 mono_error_cleanup (&error
);
3065 num_ifaces
+= ifaces
->len
;
3066 for (i
= 0; i
< ifaces
->len
; ++i
) {
3067 ic
= g_ptr_array_index (ifaces
, i
);
3068 if (max_iid
< ic
->interface_id
)
3069 max_iid
= ic
->interface_id
;
3071 ifaces_array
[j
] = ifaces
;
3075 for (i
= 0; i
< num_array_interfaces
; ++i
) {
3076 ic
= array_interfaces
[i
];
3077 mono_class_init (ic
);
3078 if (max_iid
< ic
->interface_id
)
3079 max_iid
= ic
->interface_id
;
3082 if (MONO_CLASS_IS_INTERFACE (class)) {
3084 if (max_iid
< class->interface_id
)
3085 max_iid
= class->interface_id
;
3087 class->max_interface_id
= max_iid
;
3088 /* compute vtable offset for interfaces */
3089 interfaces_full
= g_malloc0 (sizeof (MonoClass
*) * num_ifaces
);
3090 interface_offsets_full
= g_malloc (sizeof (int) * num_ifaces
);
3092 for (i
= 0; i
< num_ifaces
; i
++) {
3093 interface_offsets_full
[i
] = -1;
3096 /* skip the current class */
3097 for (j
= 0; j
< class->idepth
- 1; j
++) {
3098 k
= class->supertypes
[j
];
3099 ifaces
= ifaces_array
[j
];
3102 for (i
= 0; i
< ifaces
->len
; ++i
) {
3104 ic
= g_ptr_array_index (ifaces
, i
);
3106 /*Force the sharing of interface offsets between parent and subtypes.*/
3107 io
= mono_class_interface_offset (k
, ic
);
3109 set_interface_and_offset (num_ifaces
, interfaces_full
, interface_offsets_full
, ic
, io
, TRUE
);
3114 g_assert (class == class->supertypes
[class->idepth
- 1]);
3115 ifaces
= ifaces_array
[class->idepth
- 1];
3117 for (i
= 0; i
< ifaces
->len
; ++i
) {
3119 ic
= g_ptr_array_index (ifaces
, i
);
3120 if (set_interface_and_offset (num_ifaces
, interfaces_full
, interface_offsets_full
, ic
, cur_slot
, FALSE
))
3122 count
= count_virtual_methods (ic
);
3124 char *name
= mono_type_get_full_name (ic
);
3125 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, g_strdup_printf ("Error calculating interface offset of %s", name
));
3134 if (MONO_CLASS_IS_INTERFACE (class))
3135 set_interface_and_offset (num_ifaces
, interfaces_full
, interface_offsets_full
, class, cur_slot
, TRUE
);
3137 if (num_array_interfaces
) {
3138 if (is_enumerator
) {
3139 int ienumerator_idx
= find_array_interface (class, "IEnumerator`1");
3140 int ienumerator_offset
= find_interface_offset (num_ifaces
, interfaces_full
, interface_offsets_full
, class->interfaces
[ienumerator_idx
]);
3141 g_assert (ienumerator_offset
>= 0);
3142 for (i
= 0; i
< num_array_interfaces
; ++i
) {
3143 ic
= array_interfaces
[i
];
3144 if (strcmp (ic
->name
, "IEnumerator`1") == 0)
3145 set_interface_and_offset (num_ifaces
, interfaces_full
, interface_offsets_full
, ic
, ienumerator_offset
, TRUE
);
3147 g_assert_not_reached ();
3148 /*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);*/
3151 int ilist_offset
, icollection_offset
, ienumerable_offset
;
3152 int ilist_iface_idx
= find_array_interface (class, "IList`1");
3153 MonoClass
* ilist_class
= class->interfaces
[ilist_iface_idx
];
3154 int icollection_iface_idx
= find_array_interface (ilist_class
, "ICollection`1");
3155 int ienumerable_iface_idx
= find_array_interface (ilist_class
, "IEnumerable`1");
3156 ilist_offset
= find_interface_offset (num_ifaces
, interfaces_full
, interface_offsets_full
, class->interfaces
[ilist_iface_idx
]);
3157 icollection_offset
= find_interface_offset (num_ifaces
, interfaces_full
, interface_offsets_full
, ilist_class
->interfaces
[icollection_iface_idx
]);
3158 ienumerable_offset
= find_interface_offset (num_ifaces
, interfaces_full
, interface_offsets_full
, ilist_class
->interfaces
[ienumerable_iface_idx
]);
3159 g_assert (ilist_offset
>= 0 && icollection_offset
>= 0 && ienumerable_offset
>= 0);
3160 for (i
= 0; i
< num_array_interfaces
; ++i
) {
3162 ic
= array_interfaces
[i
];
3163 if (ic
->generic_class
->container_class
== mono_defaults
.generic_ilist_class
)
3164 offset
= ilist_offset
;
3165 else if (strcmp (ic
->name
, "ICollection`1") == 0)
3166 offset
= icollection_offset
;
3167 else if (strcmp (ic
->name
, "IEnumerable`1") == 0)
3168 offset
= ienumerable_offset
;
3170 g_assert_not_reached ();
3171 set_interface_and_offset (num_ifaces
, interfaces_full
, interface_offsets_full
, ic
, offset
, TRUE
);
3172 /*g_print ("type %s has %s offset at %d (%s)\n", class->name, ic->name, offset, class->interfaces [0]->name);*/
3177 for (interface_offsets_count
= 0, i
= 0; i
< num_ifaces
; i
++) {
3178 if (interface_offsets_full
[i
] != -1) {
3179 interface_offsets_count
++;
3184 * We might get called twice: once from mono_class_init () then once from
3185 * mono_class_setup_vtable ().
3187 if (class->interfaces_packed
) {
3188 g_assert (class->interface_offsets_count
== interface_offsets_count
);
3192 class->interface_offsets_count
= interface_offsets_count
;
3193 class->interfaces_packed
= mono_class_alloc (class, sizeof (MonoClass
*) * interface_offsets_count
);
3194 class->interface_offsets_packed
= mono_class_alloc (class, sizeof (guint16
) * interface_offsets_count
);
3195 bsize
= (sizeof (guint8
) * ((max_iid
+ 1) >> 3)) + (((max_iid
+ 1) & 7)? 1 :0);
3196 #ifdef COMPRESSED_INTERFACE_BITMAP
3197 bitmap
= g_malloc0 (bsize
);
3199 bitmap
= mono_class_alloc0 (class, bsize
);
3201 for (i
= 0; i
< interface_offsets_count
; i
++) {
3202 int id
= interfaces_full
[i
]->interface_id
;
3203 bitmap
[id
>> 3] |= (1 << (id
& 7));
3204 class->interfaces_packed
[i
] = interfaces_full
[i
];
3205 class->interface_offsets_packed
[i
] = interface_offsets_full
[i
];
3206 /*if (num_array_interfaces)
3207 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]);*/
3209 #ifdef COMPRESSED_INTERFACE_BITMAP
3210 i
= mono_compress_bitmap (NULL
, bitmap
, bsize
);
3211 class->interface_bitmap
= mono_class_alloc0 (class, i
);
3212 mono_compress_bitmap (class->interface_bitmap
, bitmap
, bsize
);
3215 class->interface_bitmap
= bitmap
;
3220 g_free (interfaces_full
);
3221 g_free (interface_offsets_full
);
3222 g_free (array_interfaces
);
3223 for (i
= 0; i
< class->idepth
; i
++) {
3224 ifaces
= ifaces_array
[i
];
3226 g_ptr_array_free (ifaces
, TRUE
);
3228 g_free (ifaces_array
);
3230 //printf ("JUST DONE: ");
3231 //print_implemented_interfaces (class);
3237 * Setup interface offsets for interfaces.
3239 * - class->max_interface_id
3240 * - class->interface_offsets_count
3241 * - class->interfaces_packed
3242 * - class->interface_offsets_packed
3243 * - class->interface_bitmap
3245 * This function can fail @class.
3248 mono_class_setup_interface_offsets (MonoClass
*class)
3250 mono_loader_lock ();
3252 setup_interface_offsets (class, 0);
3254 mono_loader_unlock ();
3258 * mono_class_setup_vtable:
3260 * Creates the generic vtable of CLASS.
3261 * Initializes the following fields in MonoClass:
3264 * Plus all the fields initialized by setup_interface_offsets ().
3265 * If there is an error during vtable construction, class->exception_type is set.
3267 * LOCKING: Acquires the loader lock.
3270 mono_class_setup_vtable (MonoClass
*class)
3272 MonoMethod
**overrides
;
3273 MonoGenericContext
*context
;
3281 if (mono_debug_using_mono_debugger ())
3282 /* The debugger currently depends on this */
3283 mono_class_setup_methods (class);
3285 if (MONO_CLASS_IS_INTERFACE (class)) {
3286 /* This sets method->slot for all methods if this is an interface */
3287 mono_class_setup_methods (class);
3291 if (class->exception_type
)
3294 mono_loader_lock ();
3296 if (class->vtable
) {
3297 mono_loader_unlock ();
3301 mono_stats
.generic_vtable_count
++;
3303 if (class->generic_class
) {
3304 context
= mono_class_get_context (class);
3305 type_token
= class->generic_class
->container_class
->type_token
;
3307 context
= (MonoGenericContext
*) class->generic_container
;
3308 type_token
= class->type_token
;
3311 if (class->image
->dynamic
) {
3312 /* Generic instances can have zero method overrides without causing any harm.
3313 * This is true since we don't do layout all over again for them, we simply inflate
3314 * the layout of the parent.
3316 mono_reflection_get_dynamic_overrides (class, &overrides
, &onum
);
3318 /* The following call fails if there are missing methods in the type */
3319 /* FIXME it's probably a good idea to avoid this for generic instances. */
3320 ok
= mono_class_get_overrides_full (class->image
, type_token
, &overrides
, &onum
, context
);
3324 mono_class_setup_vtable_general (class, overrides
, onum
);
3328 mono_loader_unlock ();
3333 #define DEBUG_INTERFACE_VTABLE_CODE 0
3334 #define TRACE_INTERFACE_VTABLE_CODE 0
3335 #define VERIFY_INTERFACE_VTABLE_CODE 0
3336 #define VTABLE_SELECTOR (1)
3338 #if (TRACE_INTERFACE_VTABLE_CODE|DEBUG_INTERFACE_VTABLE_CODE)
3339 #define DEBUG_INTERFACE_VTABLE(stmt) do {\
3340 if (!(VTABLE_SELECTOR)) break; \
3344 #define DEBUG_INTERFACE_VTABLE(stmt)
3347 #if TRACE_INTERFACE_VTABLE_CODE
3348 #define TRACE_INTERFACE_VTABLE(stmt) do {\
3349 if (!(VTABLE_SELECTOR)) break; \
3353 #define TRACE_INTERFACE_VTABLE(stmt)
3356 #if VERIFY_INTERFACE_VTABLE_CODE
3357 #define VERIFY_INTERFACE_VTABLE(stmt) do {\
3358 if (!(VTABLE_SELECTOR)) break; \
3362 #define VERIFY_INTERFACE_VTABLE(stmt)
3366 #if (TRACE_INTERFACE_VTABLE_CODE|DEBUG_INTERFACE_VTABLE_CODE)
3368 mono_signature_get_full_desc (MonoMethodSignature
*sig
, gboolean include_namespace
)
3372 GString
*res
= g_string_new ("");
3374 g_string_append_c (res
, '(');
3375 for (i
= 0; i
< sig
->param_count
; ++i
) {
3377 g_string_append_c (res
, ',');
3378 mono_type_get_desc (res
, sig
->params
[i
], include_namespace
);
3380 g_string_append (res
, ")=>");
3381 if (sig
->ret
!= NULL
) {
3382 mono_type_get_desc (res
, sig
->ret
, include_namespace
);
3384 g_string_append (res
, "NULL");
3387 g_string_free (res
, FALSE
);
3391 print_method_signatures (MonoMethod
*im
, MonoMethod
*cm
) {
3392 char *im_sig
= mono_signature_get_full_desc (mono_method_signature (im
), TRUE
);
3393 char *cm_sig
= mono_signature_get_full_desc (mono_method_signature (cm
), TRUE
);
3394 printf ("(IM \"%s\", CM \"%s\")", im_sig
, cm_sig
);
3402 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
) {
3403 MonoMethodSignature
*cmsig
, *imsig
;
3404 if (strcmp (im
->name
, cm
->name
) == 0) {
3405 if (! (cm
->flags
& METHOD_ATTRIBUTE_PUBLIC
)) {
3406 TRACE_INTERFACE_VTABLE (printf ("[PUBLIC CHECK FAILED]"));
3409 if (! slot_is_empty
) {
3410 if (require_newslot
) {
3411 if (! interface_is_explicitly_implemented_by_class
) {
3412 TRACE_INTERFACE_VTABLE (printf ("[NOT EXPLICIT IMPLEMENTATION IN FULL SLOT REFUSED]"));
3415 if (! (cm
->flags
& METHOD_ATTRIBUTE_NEW_SLOT
)) {
3416 TRACE_INTERFACE_VTABLE (printf ("[NEWSLOT CHECK FAILED]"));
3420 TRACE_INTERFACE_VTABLE (printf ("[FULL SLOT REFUSED]"));
3423 cmsig
= mono_method_signature (cm
);
3424 imsig
= mono_method_signature (im
);
3425 if (!cmsig
|| !imsig
) {
3426 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, g_strdup ("Could not resolve the signature of a virtual method"));
3430 if (! mono_metadata_signature_equal (cmsig
, imsig
)) {
3431 TRACE_INTERFACE_VTABLE (printf ("[SIGNATURE CHECK FAILED "));
3432 TRACE_INTERFACE_VTABLE (print_method_signatures (im
, cm
));
3433 TRACE_INTERFACE_VTABLE (printf ("]"));
3436 TRACE_INTERFACE_VTABLE (printf ("[SECURITY CHECKS]"));
3437 /* CAS - SecurityAction.InheritanceDemand on interface */
3438 if (security_enabled
&& (im
->flags
& METHOD_ATTRIBUTE_HAS_SECURITY
)) {
3439 mono_secman_inheritancedemand_method (cm
, im
);
3442 if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR
)
3443 mono_security_core_clr_check_override (class, cm
, im
);
3444 TRACE_INTERFACE_VTABLE (printf ("[NAME CHECK OK]"));
3447 MonoClass
*ic
= im
->klass
;
3448 const char *ic_name_space
= ic
->name_space
;
3449 const char *ic_name
= ic
->name
;
3452 if (! require_newslot
) {
3453 TRACE_INTERFACE_VTABLE (printf ("[INJECTED METHOD REFUSED]"));
3456 if (cm
->klass
->rank
== 0) {
3457 TRACE_INTERFACE_VTABLE (printf ("[RANK CHECK FAILED]"));
3460 if (! mono_metadata_signature_equal (mono_method_signature (cm
), mono_method_signature (im
))) {
3461 TRACE_INTERFACE_VTABLE (printf ("[(INJECTED) SIGNATURE CHECK FAILED "));
3462 TRACE_INTERFACE_VTABLE (print_method_signatures (im
, cm
));
3463 TRACE_INTERFACE_VTABLE (printf ("]"));
3466 if (mono_class_get_image (ic
) != mono_defaults
.corlib
) {
3467 TRACE_INTERFACE_VTABLE (printf ("[INTERFACE CORLIB CHECK FAILED]"));
3470 if ((ic_name_space
== NULL
) || (strcmp (ic_name_space
, "System.Collections.Generic") != 0)) {
3471 TRACE_INTERFACE_VTABLE (printf ("[INTERFACE NAMESPACE CHECK FAILED]"));
3474 if ((ic_name
== NULL
) || ((strcmp (ic_name
, "IEnumerable`1") != 0) && (strcmp (ic_name
, "ICollection`1") != 0) && (strcmp (ic_name
, "IList`1") != 0))) {
3475 TRACE_INTERFACE_VTABLE (printf ("[INTERFACE NAME CHECK FAILED]"));
3479 subname
= strstr (cm
->name
, ic_name_space
);
3480 if (subname
!= cm
->name
) {
3481 TRACE_INTERFACE_VTABLE (printf ("[ACTUAL NAMESPACE CHECK FAILED]"));
3484 subname
+= strlen (ic_name_space
);
3485 if (subname
[0] != '.') {
3486 TRACE_INTERFACE_VTABLE (printf ("[FIRST DOT CHECK FAILED]"));
3490 if (strstr (subname
, ic_name
) != subname
) {
3491 TRACE_INTERFACE_VTABLE (printf ("[ACTUAL CLASS NAME CHECK FAILED]"));
3494 subname
+= strlen (ic_name
);
3495 if (subname
[0] != '.') {
3496 TRACE_INTERFACE_VTABLE (printf ("[SECOND DOT CHECK FAILED]"));
3500 if (strcmp (subname
, im
->name
) != 0) {
3501 TRACE_INTERFACE_VTABLE (printf ("[METHOD NAME CHECK FAILED]"));
3505 TRACE_INTERFACE_VTABLE (printf ("[SECURITY CHECKS (INJECTED CASE)]"));
3506 /* CAS - SecurityAction.InheritanceDemand on interface */
3507 if (security_enabled
&& (im
->flags
& METHOD_ATTRIBUTE_HAS_SECURITY
)) {
3508 mono_secman_inheritancedemand_method (cm
, im
);
3511 if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR
)
3512 mono_security_core_clr_check_override (class, cm
, im
);
3514 TRACE_INTERFACE_VTABLE (printf ("[INJECTED INTERFACE CHECK OK]"));
3519 #if (TRACE_INTERFACE_VTABLE_CODE|DEBUG_INTERFACE_VTABLE_CODE)
3521 foreach_override (gpointer key
, gpointer value
, gpointer user_data
) {
3522 MonoMethod
*method
= key
;
3523 MonoMethod
*override
= value
;
3524 MonoClass
*method_class
= mono_method_get_class (method
);
3525 MonoClass
*override_class
= mono_method_get_class (override
);
3527 printf (" Method '%s.%s:%s' has override '%s.%s:%s'\n",
3528 mono_class_get_namespace (method_class
), mono_class_get_name (method_class
), mono_method_get_name (method
),
3529 mono_class_get_namespace (override_class
), mono_class_get_name (override_class
), mono_method_get_name (override
));
3532 print_overrides (GHashTable
*override_map
, const char *message
) {
3534 printf ("Override map \"%s\" START:\n", message
);
3535 g_hash_table_foreach (override_map
, foreach_override
, NULL
);
3536 printf ("Override map \"%s\" END.\n", message
);
3538 printf ("Override map \"%s\" EMPTY.\n", message
);
3542 print_vtable_full (MonoClass
*class, MonoMethod
** vtable
, int size
, int first_non_interface_slot
, const char *message
, gboolean print_interfaces
) {
3543 char *full_name
= mono_type_full_name (&class->byval_arg
);
3547 printf ("*** Vtable for class '%s' at \"%s\" (size %d)\n", full_name
, message
, size
);
3549 if (print_interfaces
) {
3550 print_implemented_interfaces (class);
3551 printf ("* Interfaces for class '%s' done.\nStarting vtable (size %d):\n", full_name
, size
);
3554 if (class->parent
) {
3555 parent_size
= class->parent
->vtable_size
;
3559 for (i
= 0; i
< size
; ++i
) {
3560 MonoMethod
*cm
= vtable
[i
];
3562 char *cm_name
= mono_method_full_name (cm
, TRUE
);
3563 char newness
= (i
< parent_size
) ? 'O' : ((i
< first_non_interface_slot
) ? 'I' : 'N');
3564 printf (" [%c][%03d][INDEX %03d] %s\n", newness
, i
, cm
->slot
, cm_name
);
3573 #if VERIFY_INTERFACE_VTABLE_CODE
3575 mono_method_try_get_vtable_index (MonoMethod
*method
)
3577 if (method
->is_inflated
&& (method
->flags
& METHOD_ATTRIBUTE_VIRTUAL
)) {
3578 MonoMethodInflated
*imethod
= (MonoMethodInflated
*)method
;
3579 if (imethod
->declaring
->is_generic
)
3580 return imethod
->declaring
->slot
;
3582 return method
->slot
;
3586 mono_class_verify_vtable (MonoClass
*class)
3589 char *full_name
= mono_type_full_name (&class->byval_arg
);
3591 printf ("*** Verifying VTable of class '%s' \n", full_name
);
3595 if (!class->methods
)
3598 for (i
= 0; i
< class->method
.count
; ++i
) {
3599 MonoMethod
*cm
= class->methods
[i
];
3602 if (!(cm
->flags
& METHOD_ATTRIBUTE_VIRTUAL
))
3606 full_name
= mono_method_full_name (cm
, TRUE
);
3608 slot
= mono_method_try_get_vtable_index (cm
);
3610 if (slot
>= class->vtable_size
) {
3611 printf ("\tInvalid method %s at index %d with vtable of length %d\n", full_name
, slot
, class->vtable_size
);
3615 if (slot
>= 0 && class->vtable
[slot
] != cm
&& (class->vtable
[slot
])) {
3616 char *other_name
= class->vtable
[slot
] ? mono_method_full_name (class->vtable
[slot
], TRUE
) : g_strdup ("[null value]");
3617 printf ("\tMethod %s has slot %d but vtable has %s on it\n", full_name
, slot
, other_name
);
3618 g_free (other_name
);
3621 printf ("\tVirtual method %s does n't have an assigned slot\n", full_name
);
3628 print_unimplemented_interface_method_info (MonoClass
*class, MonoClass
*ic
, MonoMethod
*im
, int im_slot
, MonoMethod
**overrides
, int onum
) {
3630 char *method_signature
;
3633 for (index
= 0; index
< onum
; ++index
) {
3634 g_print (" at slot %d: %s (%d) overrides %s (%d)\n", im_slot
, overrides
[index
*2+1]->name
,
3635 overrides
[index
*2+1]->slot
, overrides
[index
*2]->name
, overrides
[index
*2]->slot
);
3637 method_signature
= mono_signature_get_desc (mono_method_signature (im
), FALSE
);
3638 type_name
= mono_type_full_name (&class->byval_arg
);
3639 printf ("no implementation for interface method %s::%s(%s) in class %s\n",
3640 mono_type_get_name (&ic
->byval_arg
), im
->name
, method_signature
, type_name
);
3641 g_free (method_signature
);
3643 mono_class_setup_methods (class);
3644 if (class->exception_type
) {
3645 char *name
= mono_type_get_full_name (class);
3646 printf ("CLASS %s failed to resolve methods\n", name
);
3650 for (index
= 0; index
< class->method
.count
; ++index
) {
3651 MonoMethod
*cm
= class->methods
[index
];
3652 method_signature
= mono_signature_get_desc (mono_method_signature (cm
), TRUE
);
3654 printf ("METHOD %s(%s)\n", cm
->name
, method_signature
);
3655 g_free (method_signature
);
3660 verify_class_overrides (MonoClass
*class, MonoMethod
**overrides
, int onum
)
3664 for (i
= 0; i
< onum
; ++i
) {
3665 MonoMethod
*decl
= overrides
[i
* 2];
3666 MonoMethod
*body
= overrides
[i
* 2 + 1];
3668 if (mono_class_get_generic_type_definition (body
->klass
) != mono_class_get_generic_type_definition (class)) {
3669 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, g_strdup ("Method belongs to a different class than the declared one"));
3673 if (!(body
->flags
& METHOD_ATTRIBUTE_VIRTUAL
) || (body
->flags
& METHOD_ATTRIBUTE_STATIC
)) {
3674 if (body
->flags
& METHOD_ATTRIBUTE_STATIC
)
3675 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, g_strdup ("Method must not be static to override a base type"));
3677 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, g_strdup ("Method must be virtual to override a base type"));
3681 if (!(decl
->flags
& METHOD_ATTRIBUTE_VIRTUAL
) || (decl
->flags
& METHOD_ATTRIBUTE_STATIC
)) {
3682 if (body
->flags
& METHOD_ATTRIBUTE_STATIC
)
3683 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, g_strdup ("Cannot override a static method in a base type"));
3685 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, g_strdup ("Cannot override a non virtual method in a base type"));
3689 if (!mono_class_is_assignable_from_slow (decl
->klass
, class)) {
3690 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, g_strdup ("Method overrides a class or interface that extended or implemented by this type"));
3697 * LOCKING: this is supposed to be called with the loader lock held.
3700 mono_class_setup_vtable_general (MonoClass
*class, MonoMethod
**overrides
, int onum
)
3704 MonoMethod
**vtable
;
3705 int i
, max_vtsize
= 0, max_iid
, cur_slot
= 0;
3706 GPtrArray
*ifaces
= NULL
;
3707 GHashTable
*override_map
= NULL
;
3708 gboolean security_enabled
= mono_is_security_manager_active ();
3710 gpointer class_iter
;
3711 #if (DEBUG_INTERFACE_VTABLE_CODE|TRACE_INTERFACE_VTABLE_CODE)
3712 int first_non_interface_slot
;
3714 GSList
*virt_methods
= NULL
, *l
;
3719 if (overrides
&& !verify_class_overrides (class, overrides
, onum
))
3722 ifaces
= mono_class_get_implemented_interfaces (class, &error
);
3723 if (!mono_error_ok (&error
)) {
3724 char *name
= mono_type_get_full_name (class);
3725 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
)));
3727 mono_error_cleanup (&error
);
3729 } else if (ifaces
) {
3730 for (i
= 0; i
< ifaces
->len
; i
++) {
3731 MonoClass
*ic
= g_ptr_array_index (ifaces
, i
);
3732 max_vtsize
+= ic
->method
.count
;
3734 g_ptr_array_free (ifaces
, TRUE
);
3738 if (class->parent
) {
3739 mono_class_init (class->parent
);
3740 mono_class_setup_vtable (class->parent
);
3742 if (class->parent
->exception_type
) {
3743 char *name
= mono_type_get_full_name (class->parent
);
3744 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, g_strdup_printf ("Parent %s failed to load", name
));
3749 max_vtsize
+= class->parent
->vtable_size
;
3750 cur_slot
= class->parent
->vtable_size
;
3753 max_vtsize
+= class->method
.count
;
3755 vtable
= alloca (sizeof (gpointer
) * max_vtsize
);
3756 memset (vtable
, 0, sizeof (gpointer
) * max_vtsize
);
3758 /* printf ("METAINIT %s.%s\n", class->name_space, class->name); */
3760 cur_slot
= setup_interface_offsets (class, cur_slot
);
3761 if (cur_slot
== -1) /*setup_interface_offsets fails the type.*/
3764 max_iid
= class->max_interface_id
;
3765 DEBUG_INTERFACE_VTABLE (first_non_interface_slot
= cur_slot
);
3767 /* Optimized version for generic instances */
3768 if (class->generic_class
) {
3770 MonoClass
*gklass
= class->generic_class
->container_class
;
3773 mono_class_setup_vtable (gklass
);
3774 if (gklass
->exception_type
!= MONO_EXCEPTION_NONE
) {
3775 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, NULL
);
3779 tmp
= mono_class_alloc0 (class, sizeof (gpointer
) * gklass
->vtable_size
);
3780 class->vtable_size
= gklass
->vtable_size
;
3781 for (i
= 0; i
< gklass
->vtable_size
; ++i
)
3782 if (gklass
->vtable
[i
]) {
3783 MonoMethod
*inflated
= mono_class_inflate_generic_method_full_checked (gklass
->vtable
[i
], class, mono_class_get_context (class), &error
);
3784 if (!mono_error_ok (&error
)) {
3785 char *err_msg
= g_strdup_printf ("Could not inflate method due to %s", mono_error_get_message (&error
));
3786 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, err_msg
);
3788 mono_error_cleanup (&error
);
3792 tmp
[i
]->slot
= gklass
->vtable
[i
]->slot
;
3794 mono_memory_barrier ();
3795 class->vtable
= tmp
;
3797 /* Have to set method->slot for abstract virtual methods */
3798 if (class->methods
&& gklass
->methods
) {
3799 for (i
= 0; i
< class->method
.count
; ++i
)
3800 if (class->methods
[i
]->slot
== -1)
3801 class->methods
[i
]->slot
= gklass
->methods
[i
]->slot
;
3807 if (class->parent
&& class->parent
->vtable_size
) {
3808 MonoClass
*parent
= class->parent
;
3811 memcpy (vtable
, parent
->vtable
, sizeof (gpointer
) * parent
->vtable_size
);
3813 // Also inherit parent interface vtables, just as a starting point.
3814 // This is needed otherwise bug-77127.exe fails when the property methods
3815 // have different names in the iterface and the class, because for child
3816 // classes the ".override" information is not used anymore.
3817 for (i
= 0; i
< parent
->interface_offsets_count
; i
++) {
3818 MonoClass
*parent_interface
= parent
->interfaces_packed
[i
];
3819 int interface_offset
= mono_class_interface_offset (class, parent_interface
);
3820 /*FIXME this is now dead code as this condition will never hold true.
3821 Since interface offsets are inherited then the offset of an interface implemented
3822 by a parent will never be the out of it's vtable boundary.
3824 if (interface_offset
>= parent
->vtable_size
) {
3825 int parent_interface_offset
= mono_class_interface_offset (parent
, parent_interface
);
3828 mono_class_setup_methods (parent_interface
); /*FIXME Just kill this whole chunk of dead code*/
3829 TRACE_INTERFACE_VTABLE (printf (" +++ Inheriting interface %s.%s\n", parent_interface
->name_space
, parent_interface
->name
));
3830 for (j
= 0; j
< parent_interface
->method
.count
&& !class->exception_type
; j
++) {
3831 vtable
[interface_offset
+ j
] = parent
->vtable
[parent_interface_offset
+ j
];
3832 TRACE_INTERFACE_VTABLE (printf (" --- Inheriting: [%03d][(%03d)+(%03d)] => [%03d][(%03d)+(%03d)]\n",
3833 parent_interface_offset
+ j
, parent_interface_offset
, j
,
3834 interface_offset
+ j
, interface_offset
, j
));
3841 TRACE_INTERFACE_VTABLE (print_vtable_full (class, vtable
, cur_slot
, first_non_interface_slot
, "AFTER INHERITING PARENT VTABLE", TRUE
));
3842 /* override interface methods */
3843 for (i
= 0; i
< onum
; i
++) {
3844 MonoMethod
*decl
= overrides
[i
*2];
3845 if (MONO_CLASS_IS_INTERFACE (decl
->klass
)) {
3847 dslot
= mono_method_get_vtable_slot (decl
);
3849 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, NULL
);
3853 dslot
+= mono_class_interface_offset (class, decl
->klass
);
3854 vtable
[dslot
] = overrides
[i
*2 + 1];
3855 vtable
[dslot
]->slot
= dslot
;
3857 override_map
= g_hash_table_new (mono_aligned_addr_hash
, NULL
);
3859 g_hash_table_insert (override_map
, overrides
[i
* 2], overrides
[i
* 2 + 1]);
3861 if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR
)
3862 mono_security_core_clr_check_override (class, vtable
[dslot
], decl
);
3865 TRACE_INTERFACE_VTABLE (print_overrides (override_map
, "AFTER OVERRIDING INTERFACE METHODS"));
3866 TRACE_INTERFACE_VTABLE (print_vtable_full (class, vtable
, cur_slot
, first_non_interface_slot
, "AFTER OVERRIDING INTERFACE METHODS", FALSE
));
3869 * Create a list of virtual methods to avoid calling
3870 * mono_class_get_virtual_methods () which is slow because of the metadata
3874 gpointer iter
= NULL
;
3877 virt_methods
= NULL
;
3878 while ((cm
= mono_class_get_virtual_methods (class, &iter
))) {
3879 virt_methods
= g_slist_prepend (virt_methods
, cm
);
3881 if (class->exception_type
)
3885 // Loop on all implemented interfaces...
3886 for (i
= 0; i
< class->interface_offsets_count
; i
++) {
3887 MonoClass
*parent
= class->parent
;
3889 gboolean interface_is_explicitly_implemented_by_class
;
3892 ic
= class->interfaces_packed
[i
];
3893 ic_offset
= mono_class_interface_offset (class, ic
);
3895 mono_class_setup_methods (ic
);
3896 if (ic
->exception_type
)
3899 // Check if this interface is explicitly implemented (instead of just inherited)
3900 if (parent
!= NULL
) {
3901 int implemented_interfaces_index
;
3902 interface_is_explicitly_implemented_by_class
= FALSE
;
3903 for (implemented_interfaces_index
= 0; implemented_interfaces_index
< class->interface_count
; implemented_interfaces_index
++) {
3904 if (ic
== class->interfaces
[implemented_interfaces_index
]) {
3905 interface_is_explicitly_implemented_by_class
= TRUE
;
3910 interface_is_explicitly_implemented_by_class
= TRUE
;
3913 // Loop on all interface methods...
3914 for (im_index
= 0; im_index
< ic
->method
.count
; im_index
++) {
3915 MonoMethod
*im
= ic
->methods
[im_index
];
3916 int im_slot
= ic_offset
+ im
->slot
;
3917 MonoMethod
*override_im
= (override_map
!= NULL
) ? g_hash_table_lookup (override_map
, im
) : NULL
;
3919 if (im
->flags
& METHOD_ATTRIBUTE_STATIC
)
3922 // If there is an explicit implementation, just use it right away,
3923 // otherwise look for a matching method
3924 if (override_im
== NULL
) {
3929 // First look for a suitable method among the class methods
3931 for (l
= virt_methods
; l
; l
= l
->next
) {
3933 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
)));
3934 if (check_interface_method_override (class, im
, cm
, TRUE
, interface_is_explicitly_implemented_by_class
, (vtable
[im_slot
] == NULL
), security_enabled
)) {
3935 TRACE_INTERFACE_VTABLE (printf ("[check ok]: ASSIGNING"));
3936 vtable
[im_slot
] = cm
;
3937 /* Why do we need this? */
3942 TRACE_INTERFACE_VTABLE (printf ("\n"));
3943 if (class->exception_type
) /*Might be set by check_interface_method_override*/
3947 // If the slot is still empty, look in all the inherited virtual methods...
3948 if ((vtable
[im_slot
] == NULL
) && class->parent
!= NULL
) {
3949 MonoClass
*parent
= class->parent
;
3950 // Reverse order, so that last added methods are preferred
3951 for (cm_index
= parent
->vtable_size
- 1; cm_index
>= 0; cm_index
--) {
3952 MonoMethod
*cm
= parent
->vtable
[cm_index
];
3954 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
));
3955 if ((cm
!= NULL
) && check_interface_method_override (class, im
, cm
, FALSE
, FALSE
, TRUE
, security_enabled
)) {
3956 TRACE_INTERFACE_VTABLE (printf ("[everything ok]: ASSIGNING"));
3957 vtable
[im_slot
] = cm
;
3958 /* Why do we need this? */
3964 if (class->exception_type
) /*Might be set by check_interface_method_override*/
3966 TRACE_INTERFACE_VTABLE ((cm
!= NULL
) && printf ("\n"));
3970 g_assert (vtable
[im_slot
] == override_im
);
3975 // If the class is not abstract, check that all its interface slots are full.
3976 // The check is done here and not directly at the end of the loop above because
3977 // it can happen (for injected generic array interfaces) that the same slot is
3978 // processed multiple times (those interfaces have overlapping slots), and it
3979 // will not always be the first pass the one that fills the slot.
3980 if (! (class->flags
& TYPE_ATTRIBUTE_ABSTRACT
)) {
3981 for (i
= 0; i
< class->interface_offsets_count
; i
++) {
3985 ic
= class->interfaces_packed
[i
];
3986 ic_offset
= mono_class_interface_offset (class, ic
);
3988 for (im_index
= 0; im_index
< ic
->method
.count
; im_index
++) {
3989 MonoMethod
*im
= ic
->methods
[im_index
];
3990 int im_slot
= ic_offset
+ im
->slot
;
3992 if (im
->flags
& METHOD_ATTRIBUTE_STATIC
)
3995 TRACE_INTERFACE_VTABLE (printf (" [class is not abstract, checking slot %d for interface '%s'.'%s', method %s, slot check is %d]\n",
3996 im_slot
, ic
->name_space
, ic
->name
, im
->name
, (vtable
[im_slot
] == NULL
)));
3997 if (vtable
[im_slot
] == NULL
) {
3998 print_unimplemented_interface_method_info (class, ic
, im
, im_slot
, overrides
, onum
);
4005 TRACE_INTERFACE_VTABLE (print_vtable_full (class, vtable
, cur_slot
, first_non_interface_slot
, "AFTER SETTING UP INTERFACE METHODS", FALSE
));
4007 for (l
= virt_methods
; l
; l
= l
->next
) {
4010 * If the method is REUSE_SLOT, we must check in the
4011 * base class for a method to override.
4013 if (!(cm
->flags
& METHOD_ATTRIBUTE_NEW_SLOT
)) {
4015 for (k
= class->parent
; k
; k
= k
->parent
) {
4020 while ((m1
= mono_class_get_virtual_methods (k
, &k_iter
))) {
4021 MonoMethodSignature
*cmsig
, *m1sig
;
4023 cmsig
= mono_method_signature (cm
);
4024 m1sig
= mono_method_signature (m1
);
4026 if (!cmsig
|| !m1sig
) {
4027 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, NULL
);
4031 if (!strcmp(cm
->name
, m1
->name
) &&
4032 mono_metadata_signature_equal (cmsig
, m1sig
)) {
4034 /* CAS - SecurityAction.InheritanceDemand */
4035 if (security_enabled
&& (m1
->flags
& METHOD_ATTRIBUTE_HAS_SECURITY
)) {
4036 mono_secman_inheritancedemand_method (cm
, m1
);
4039 if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR
)
4040 mono_security_core_clr_check_override (class, cm
, m1
);
4042 slot
= mono_method_get_vtable_slot (m1
);
4046 g_assert (cm
->slot
< max_vtsize
);
4048 override_map
= g_hash_table_new (mono_aligned_addr_hash
, NULL
);
4049 g_hash_table_insert (override_map
, m1
, cm
);
4053 if (k
->exception_type
)
4063 /*Non final newslot methods must be given a non-interface vtable slot*/
4064 if ((cm
->flags
& METHOD_ATTRIBUTE_NEW_SLOT
) && !(cm
->flags
& METHOD_ATTRIBUTE_FINAL
) && cm
->slot
>= 0)
4068 cm
->slot
= cur_slot
++;
4070 if (!(cm
->flags
& METHOD_ATTRIBUTE_ABSTRACT
))
4071 vtable
[cm
->slot
] = cm
;
4074 /* override non interface methods */
4075 for (i
= 0; i
< onum
; i
++) {
4076 MonoMethod
*decl
= overrides
[i
*2];
4077 if (!MONO_CLASS_IS_INTERFACE (decl
->klass
)) {
4078 g_assert (decl
->slot
!= -1);
4079 vtable
[decl
->slot
] = overrides
[i
*2 + 1];
4080 overrides
[i
* 2 + 1]->slot
= decl
->slot
;
4082 override_map
= g_hash_table_new (mono_aligned_addr_hash
, NULL
);
4083 g_hash_table_insert (override_map
, decl
, overrides
[i
* 2 + 1]);
4085 if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR
)
4086 mono_security_core_clr_check_override (class, vtable
[decl
->slot
], decl
);
4091 * If a method occupies more than one place in the vtable, and it is
4092 * overriden, then change the other occurances too.
4095 for (i
= 0; i
< max_vtsize
; ++i
)
4097 MonoMethod
*cm
= g_hash_table_lookup (override_map
, vtable
[i
]);
4102 g_hash_table_destroy (override_map
);
4103 override_map
= NULL
;
4106 g_slist_free (virt_methods
);
4107 virt_methods
= NULL
;
4109 /* Ensure that all vtable slots are filled with concrete instance methods */
4110 if (!(class->flags
& TYPE_ATTRIBUTE_ABSTRACT
)) {
4111 for (i
= 0; i
< cur_slot
; ++i
) {
4112 if (vtable
[i
] == NULL
|| (vtable
[i
]->flags
& (METHOD_ATTRIBUTE_ABSTRACT
| METHOD_ATTRIBUTE_STATIC
))) {
4113 char *type_name
= mono_type_get_full_name (class);
4114 char *method_name
= vtable
[i
] ? mono_method_full_name (vtable
[i
], TRUE
) : g_strdup ("none");
4115 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
));
4117 g_free (method_name
);
4123 if (class->generic_class
) {
4124 MonoClass
*gklass
= class->generic_class
->container_class
;
4126 mono_class_init (gklass
);
4128 class->vtable_size
= MAX (gklass
->vtable_size
, cur_slot
);
4130 /* Check that the vtable_size value computed in mono_class_init () is correct */
4131 if (class->vtable_size
)
4132 g_assert (cur_slot
== class->vtable_size
);
4133 class->vtable_size
= cur_slot
;
4136 /* Try to share the vtable with our parent. */
4137 if (class->parent
&& (class->parent
->vtable_size
== class->vtable_size
) && (memcmp (class->parent
->vtable
, vtable
, sizeof (gpointer
) * class->vtable_size
) == 0)) {
4138 mono_memory_barrier ();
4139 class->vtable
= class->parent
->vtable
;
4141 MonoMethod
**tmp
= mono_class_alloc0 (class, sizeof (gpointer
) * class->vtable_size
);
4142 memcpy (tmp
, vtable
, sizeof (gpointer
) * class->vtable_size
);
4143 mono_memory_barrier ();
4144 class->vtable
= tmp
;
4147 DEBUG_INTERFACE_VTABLE (print_vtable_full (class, class->vtable
, class->vtable_size
, first_non_interface_slot
, "FINALLY", FALSE
));
4148 if (mono_print_vtable
) {
4151 print_implemented_interfaces (class);
4153 for (i
= 0; i
<= max_iid
; i
++)
4154 if (MONO_CLASS_IMPLEMENTS_INTERFACE (class, i
))
4157 printf ("VTable %s (vtable entries = %d, interfaces = %d)\n", mono_type_full_name (&class->byval_arg
),
4158 class->vtable_size
, icount
);
4160 for (i
= 0; i
< cur_slot
; ++i
) {
4165 printf (" slot assigned: %03d, slot index: %03d %s\n", i
, cm
->slot
,
4166 mono_method_full_name (cm
, TRUE
));
4172 printf ("Interfaces %s.%s (max_iid = %d)\n", class->name_space
,
4173 class->name
, max_iid
);
4175 for (i
= 0; i
< class->interface_count
; i
++) {
4176 ic
= class->interfaces
[i
];
4177 printf (" slot offset: %03d, method count: %03d, iid: %03d %s\n",
4178 mono_class_interface_offset (class, ic
),
4179 count_virtual_methods (ic
), ic
->interface_id
, mono_type_full_name (&ic
->byval_arg
));
4182 for (k
= class->parent
; k
; k
= k
->parent
) {
4183 for (i
= 0; i
< k
->interface_count
; i
++) {
4184 ic
= k
->interfaces
[i
];
4185 printf (" parent slot offset: %03d, method count: %03d, iid: %03d %s\n",
4186 mono_class_interface_offset (class, ic
),
4187 count_virtual_methods (ic
), ic
->interface_id
, mono_type_full_name (&ic
->byval_arg
));
4193 VERIFY_INTERFACE_VTABLE (mono_class_verify_vtable (class));
4198 char *name
= mono_type_get_full_name (class);
4199 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, g_strdup_printf ("VTable setup of type %s failed", name
));
4202 g_hash_table_destroy (override_map
);
4204 g_slist_free (virt_methods
);
4209 * mono_method_get_vtable_slot:
4211 * Returns method->slot, computing it if neccesary. Return -1 on failure.
4212 * LOCKING: Acquires the loader lock.
4214 * FIXME Use proper MonoError machinery here.
4217 mono_method_get_vtable_slot (MonoMethod
*method
)
4219 if (method
->slot
== -1) {
4220 mono_class_setup_vtable (method
->klass
);
4221 if (method
->klass
->exception_type
)
4223 g_assert (method
->slot
!= -1);
4225 return method
->slot
;
4229 * mono_method_get_vtable_index:
4232 * Returns the index into the runtime vtable to access the method or,
4233 * in the case of a virtual generic method, the virtual generic method
4234 * thunk. Returns -1 on failure.
4236 * FIXME Use proper MonoError machinery here.
4239 mono_method_get_vtable_index (MonoMethod
*method
)
4241 if (method
->is_inflated
&& (method
->flags
& METHOD_ATTRIBUTE_VIRTUAL
)) {
4242 MonoMethodInflated
*imethod
= (MonoMethodInflated
*)method
;
4243 if (imethod
->declaring
->is_generic
)
4244 return mono_method_get_vtable_slot (imethod
->declaring
);
4246 return mono_method_get_vtable_slot (method
);
4249 static MonoMethod
*default_ghc
= NULL
;
4250 static MonoMethod
*default_finalize
= NULL
;
4251 static int finalize_slot
= -1;
4252 static int ghc_slot
= -1;
4255 initialize_object_slots (MonoClass
*class)
4260 if (class == mono_defaults
.object_class
) {
4261 mono_class_setup_vtable (class);
4262 for (i
= 0; i
< class->vtable_size
; ++i
) {
4263 MonoMethod
*cm
= class->vtable
[i
];
4265 if (!strcmp (cm
->name
, "GetHashCode"))
4267 else if (!strcmp (cm
->name
, "Finalize"))
4271 g_assert (ghc_slot
> 0);
4272 default_ghc
= class->vtable
[ghc_slot
];
4274 g_assert (finalize_slot
> 0);
4275 default_finalize
= class->vtable
[finalize_slot
];
4280 MonoMethod
*array_method
;
4282 } GenericArrayMethodInfo
;
4284 static int generic_array_method_num
= 0;
4285 static GenericArrayMethodInfo
*generic_array_method_info
= NULL
;
4288 generic_array_methods (MonoClass
*class)
4290 int i
, count_generic
= 0;
4291 GList
*list
= NULL
, *tmp
;
4292 if (generic_array_method_num
)
4293 return generic_array_method_num
;
4294 mono_class_setup_methods (class->parent
); /*This is setting up System.Array*/
4295 g_assert (!class->parent
->exception_type
); /*So hitting this assert is a huge problem*/
4296 for (i
= 0; i
< class->parent
->method
.count
; i
++) {
4297 MonoMethod
*m
= class->parent
->methods
[i
];
4298 if (!strncmp (m
->name
, "InternalArray__", 15)) {
4300 list
= g_list_prepend (list
, m
);
4303 list
= g_list_reverse (list
);
4304 generic_array_method_info
= g_malloc (sizeof (GenericArrayMethodInfo
) * count_generic
);
4306 for (tmp
= list
; tmp
; tmp
= tmp
->next
) {
4307 const char *mname
, *iname
;
4309 MonoMethod
*m
= tmp
->data
;
4310 generic_array_method_info
[i
].array_method
= m
;
4311 if (!strncmp (m
->name
, "InternalArray__ICollection_", 27)) {
4312 iname
= "System.Collections.Generic.ICollection`1.";
4313 mname
= m
->name
+ 27;
4314 } else if (!strncmp (m
->name
, "InternalArray__IEnumerable_", 27)) {
4315 iname
= "System.Collections.Generic.IEnumerable`1.";
4316 mname
= m
->name
+ 27;
4317 } else if (!strncmp (m
->name
, "InternalArray__", 15)) {
4318 iname
= "System.Collections.Generic.IList`1.";
4319 mname
= m
->name
+ 15;
4321 g_assert_not_reached ();
4324 name
= mono_image_alloc (mono_defaults
.corlib
, strlen (iname
) + strlen (mname
) + 1);
4325 strcpy (name
, iname
);
4326 strcpy (name
+ strlen (iname
), mname
);
4327 generic_array_method_info
[i
].name
= name
;
4330 /*g_print ("array generic methods: %d\n", count_generic);*/
4332 generic_array_method_num
= count_generic
;
4334 return generic_array_method_num
;
4338 setup_generic_array_ifaces (MonoClass
*class, MonoClass
*iface
, MonoMethod
**methods
, int pos
)
4340 MonoGenericContext tmp_context
;
4343 tmp_context
.class_inst
= NULL
;
4344 tmp_context
.method_inst
= iface
->generic_class
->context
.class_inst
;
4345 //g_print ("setting up array interface: %s\n", mono_type_get_name_full (&iface->byval_arg, 0));
4347 for (i
= 0; i
< generic_array_method_num
; i
++) {
4348 MonoMethod
*m
= generic_array_method_info
[i
].array_method
;
4349 MonoMethod
*inflated
;
4351 inflated
= mono_class_inflate_generic_method (m
, &tmp_context
);
4352 methods
[pos
++] = mono_marshal_get_generic_array_helper (class, iface
, generic_array_method_info
[i
].name
, inflated
);
4357 concat_two_strings_with_zero (MonoImage
*image
, const char *s1
, const char *s2
)
4359 int len
= strlen (s1
) + strlen (s2
) + 2;
4360 char *s
= mono_image_alloc (image
, len
);
4363 result
= g_snprintf (s
, len
, "%s%c%s", s1
, '\0', s2
);
4364 g_assert (result
== len
- 1);
4370 set_failure_from_loader_error (MonoClass
*class, MonoLoaderError
*error
)
4372 gpointer exception_data
= NULL
;
4374 switch (error
->exception_type
) {
4375 case MONO_EXCEPTION_TYPE_LOAD
:
4376 exception_data
= concat_two_strings_with_zero (class->image
, error
->class_name
, error
->assembly_name
);
4379 case MONO_EXCEPTION_MISSING_METHOD
:
4380 exception_data
= concat_two_strings_with_zero (class->image
, error
->class_name
, error
->member_name
);
4383 case MONO_EXCEPTION_MISSING_FIELD
: {
4384 const char *name_space
= error
->klass
->name_space
? error
->klass
->name_space
: NULL
;
4385 const char *class_name
;
4388 class_name
= g_strdup_printf ("%s.%s", name_space
, error
->klass
->name
);
4390 class_name
= error
->klass
->name
;
4392 exception_data
= concat_two_strings_with_zero (class->image
, class_name
, error
->member_name
);
4395 g_free ((void*)class_name
);
4399 case MONO_EXCEPTION_FILE_NOT_FOUND
: {
4402 if (error
->ref_only
)
4403 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.";
4405 msg
= "Could not load file or assembly '%s' or one of its dependencies.";
4407 exception_data
= concat_two_strings_with_zero (class->image
, msg
, error
->assembly_name
);
4411 case MONO_EXCEPTION_BAD_IMAGE
:
4412 exception_data
= error
->msg
;
4416 g_assert_not_reached ();
4419 mono_class_set_failure (class, error
->exception_type
, exception_data
);
4424 * @class: the class to initialize
4426 * Compute the instance_size, class_size and other infos that cannot be
4427 * computed at mono_class_get() time. Also compute vtable_size if possible.
4428 * Returns TRUE on success or FALSE if there was a problem in loading
4429 * the type (incorrect assemblies, missing assemblies, methods, etc).
4431 * LOCKING: Acquires the loader lock.
4434 mono_class_init (MonoClass
*class)
4437 MonoCachedClassInfo cached_info
;
4438 gboolean has_cached_info
;
4442 /* Double-checking locking pattern */
4444 return class->exception_type
== MONO_EXCEPTION_NONE
;
4446 /*g_print ("Init class %s\n", class->name);*/
4448 /* We do everything inside the lock to prevent races */
4449 mono_loader_lock ();
4451 if (class->inited
) {
4452 mono_loader_unlock ();
4453 /* Somebody might have gotten in before us */
4454 return class->exception_type
== MONO_EXCEPTION_NONE
;
4457 if (class->init_pending
) {
4458 mono_loader_unlock ();
4459 /* this indicates a cyclic dependency */
4460 g_error ("pending init %s.%s\n", class->name_space
, class->name
);
4463 class->init_pending
= 1;
4465 if (mono_verifier_is_enabled_for_class (class) && !mono_verifier_verify_class (class)) {
4466 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, concat_two_strings_with_zero (class->image
, class->name
, class->image
->assembly_name
));
4471 if (class->byval_arg
.type
== MONO_TYPE_ARRAY
|| class->byval_arg
.type
== MONO_TYPE_SZARRAY
) {
4472 MonoClass
*element_class
= class->element_class
;
4473 if (!element_class
->inited
)
4474 mono_class_init (element_class
);
4475 if (element_class
->exception_type
!= MONO_EXCEPTION_NONE
) {
4476 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, NULL
);
4481 /* CAS - SecurityAction.InheritanceDemand */
4482 if (mono_is_security_manager_active () && class->parent
&& (class->parent
->flags
& TYPE_ATTRIBUTE_HAS_SECURITY
)) {
4483 mono_secman_inheritancedemand_class (class, class->parent
);
4486 mono_stats
.initialized_class_count
++;
4488 if (class->generic_class
&& !class->generic_class
->is_dynamic
) {
4489 MonoClass
*gklass
= class->generic_class
->container_class
;
4491 mono_stats
.generic_class_count
++;
4493 class->method
= gklass
->method
;
4494 class->field
= gklass
->field
;
4496 mono_class_init (gklass
);
4497 // FIXME: Why is this needed ?
4498 if (!gklass
->exception_type
)
4499 mono_class_setup_methods (gklass
);
4500 if (gklass
->exception_type
) {
4501 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, g_strdup_printf ("Generic Type Defintion failed to init"));
4505 if (MONO_CLASS_IS_INTERFACE (class))
4506 class->interface_id
= mono_get_unique_iid (class);
4509 if (class->parent
&& !class->parent
->inited
)
4510 mono_class_init (class->parent
);
4512 has_cached_info
= mono_class_get_cached_class_info (class, &cached_info
);
4514 if (class->generic_class
|| class->image
->dynamic
|| !class->type_token
|| (has_cached_info
&& !cached_info
.has_nested_classes
))
4515 class->nested_classes_inited
= TRUE
;
4518 * Computes the size used by the fields, and their locations
4520 if (has_cached_info
) {
4521 class->instance_size
= cached_info
.instance_size
;
4522 class->sizes
.class_size
= cached_info
.class_size
;
4523 class->packing_size
= cached_info
.packing_size
;
4524 class->min_align
= cached_info
.min_align
;
4525 class->blittable
= cached_info
.blittable
;
4526 class->has_references
= cached_info
.has_references
;
4527 class->has_static_refs
= cached_info
.has_static_refs
;
4528 class->no_special_static_fields
= cached_info
.no_special_static_fields
;
4531 if (!class->size_inited
){
4532 mono_class_setup_fields (class);
4533 if (class->exception_type
|| mono_loader_get_last_error ())
4537 /* Initialize arrays */
4539 class->method
.count
= 3 + (class->rank
> 1? 2: 1);
4541 if (class->interface_count
) {
4542 int count_generic
= generic_array_methods (class);
4543 class->method
.count
+= class->interface_count
* count_generic
;
4547 mono_class_setup_supertypes (class);
4550 initialize_object_slots (class);
4553 * Initialize the rest of the data without creating a generic vtable if possible.
4554 * If possible, also compute vtable_size, so mono_class_create_runtime_vtable () can
4555 * also avoid computing a generic vtable.
4557 if (has_cached_info
) {
4559 class->vtable_size
= cached_info
.vtable_size
;
4560 class->has_finalize
= cached_info
.has_finalize
;
4561 class->ghcimpl
= cached_info
.ghcimpl
;
4562 class->has_cctor
= cached_info
.has_cctor
;
4563 } else if (class->rank
== 1 && class->byval_arg
.type
== MONO_TYPE_SZARRAY
) {
4564 static int szarray_vtable_size
= 0;
4567 if (!szarray_vtable_size
) {
4568 mono_class_setup_vtable (class);
4569 szarray_vtable_size
= class->vtable_size
;
4571 class->vtable_size
= szarray_vtable_size
;
4573 } else if (class->generic_class
&& !MONO_CLASS_IS_INTERFACE (class)) {
4574 MonoClass
*gklass
= class->generic_class
->container_class
;
4576 /* Generic instance case */
4577 class->ghcimpl
= gklass
->ghcimpl
;
4578 class->has_finalize
= gklass
->has_finalize
;
4579 class->has_cctor
= gklass
->has_cctor
;
4581 mono_class_setup_vtable (gklass
);
4582 if (gklass
->exception_type
) {
4583 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, NULL
);
4587 class->vtable_size
= gklass
->vtable_size
;
4591 /* ghcimpl is not currently used
4593 if (class->parent) {
4594 MonoMethod *cmethod = class->vtable [ghc_slot];
4595 if (cmethod->is_inflated)
4596 cmethod = ((MonoMethodInflated*)cmethod)->declaring;
4597 if (cmethod == default_ghc) {
4603 /* Interfaces and valuetypes are not supposed to have finalizers */
4604 if (!(MONO_CLASS_IS_INTERFACE (class) || class->valuetype
)) {
4605 MonoMethod
*cmethod
= NULL
;
4607 if (class->parent
&& class->parent
->has_finalize
) {
4608 class->has_finalize
= 1;
4610 if (class->type_token
) {
4611 cmethod
= find_method_in_metadata (class, "Finalize", 0, METHOD_ATTRIBUTE_VIRTUAL
);
4612 } else if (class->parent
) {
4613 /* FIXME: Optimize this */
4614 mono_class_setup_vtable (class);
4615 if (class->exception_type
|| mono_loader_get_last_error ())
4617 cmethod
= class->vtable
[finalize_slot
];
4621 /* Check that this is really the finalizer method */
4622 mono_class_setup_vtable (class);
4623 if (class->exception_type
|| mono_loader_get_last_error ())
4626 g_assert (class->vtable_size
> finalize_slot
);
4628 class->has_finalize
= 0;
4629 if (class->parent
) {
4630 cmethod
= class->vtable
[finalize_slot
];
4632 if (cmethod
->is_inflated
)
4633 cmethod
= ((MonoMethodInflated
*)cmethod
)->declaring
;
4634 if (cmethod
!= default_finalize
) {
4635 class->has_finalize
= 1;
4642 /* C# doesn't allow interfaces to have cctors */
4643 if (!MONO_CLASS_IS_INTERFACE (class) || class->image
!= mono_defaults
.corlib
) {
4644 MonoMethod
*cmethod
= NULL
;
4646 if (class->type_token
) {
4647 cmethod
= find_method_in_metadata (class, ".cctor", 0, METHOD_ATTRIBUTE_SPECIAL_NAME
);
4648 /* The find_method function ignores the 'flags' argument */
4649 if (cmethod
&& (cmethod
->flags
& METHOD_ATTRIBUTE_SPECIAL_NAME
))
4650 class->has_cctor
= 1;
4652 mono_class_setup_methods (class);
4653 if (class->exception_type
)
4656 for (i
= 0; i
< class->method
.count
; ++i
) {
4657 MonoMethod
*method
= class->methods
[i
];
4658 if ((method
->flags
& METHOD_ATTRIBUTE_SPECIAL_NAME
) &&
4659 (strcmp (".cctor", method
->name
) == 0)) {
4660 class->has_cctor
= 1;
4668 if (class->parent
) {
4669 /* This will compute class->parent->vtable_size for some classes */
4670 mono_class_init (class->parent
);
4671 if (class->parent
->exception_type
) {
4672 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, NULL
);
4675 if (mono_loader_get_last_error ())
4677 if (!class->parent
->vtable_size
) {
4678 /* FIXME: Get rid of this somehow */
4679 mono_class_setup_vtable (class->parent
);
4680 if (class->parent
->exception_type
) {
4681 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, NULL
);
4684 if (mono_loader_get_last_error ())
4687 setup_interface_offsets (class, class->parent
->vtable_size
);
4689 setup_interface_offsets (class, 0);
4692 if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR
)
4693 mono_security_core_clr_check_inheritance (class);
4695 if (mono_loader_get_last_error ()) {
4696 if (class->exception_type
== MONO_EXCEPTION_NONE
) {
4697 set_failure_from_loader_error (class, mono_loader_get_last_error ());
4699 mono_loader_clear_error ();
4705 /* Because of the double-checking locking pattern */
4706 mono_memory_barrier ();
4708 class->init_pending
= 0;
4710 mono_loader_unlock ();
4712 if (mono_debugger_class_init_func
)
4713 mono_debugger_class_init_func (class);
4715 return class->exception_type
== MONO_EXCEPTION_NONE
;
4719 is_corlib_image (MonoImage
*image
)
4721 /* FIXME: allow the dynamic case for our compilers and with full trust */
4723 return image
->assembly
&& !strcmp (image
->assembly
->aname
.name
, "mscorlib");
4725 return image
== mono_defaults
.corlib
;
4729 * LOCKING: this assumes the loader lock is held
4732 mono_class_setup_mono_type (MonoClass
*class)
4734 const char *name
= class->name
;
4735 const char *nspace
= class->name_space
;
4736 gboolean is_corlib
= is_corlib_image (class->image
);
4738 class->this_arg
.byref
= 1;
4739 class->this_arg
.data
.klass
= class;
4740 class->this_arg
.type
= MONO_TYPE_CLASS
;
4741 class->byval_arg
.data
.klass
= class;
4742 class->byval_arg
.type
= MONO_TYPE_CLASS
;
4744 if (is_corlib
&& !strcmp (nspace
, "System")) {
4745 if (!strcmp (name
, "ValueType")) {
4747 * do not set the valuetype bit for System.ValueType.
4748 * class->valuetype = 1;
4750 class->blittable
= TRUE
;
4751 } else if (!strcmp (name
, "Enum")) {
4753 * do not set the valuetype bit for System.Enum.
4754 * class->valuetype = 1;
4756 class->valuetype
= 0;
4757 class->enumtype
= 0;
4758 } else if (!strcmp (name
, "Object")) {
4759 class->this_arg
.type
= class->byval_arg
.type
= MONO_TYPE_OBJECT
;
4760 } else if (!strcmp (name
, "String")) {
4761 class->this_arg
.type
= class->byval_arg
.type
= MONO_TYPE_STRING
;
4762 } else if (!strcmp (name
, "TypedReference")) {
4763 class->this_arg
.type
= class->byval_arg
.type
= MONO_TYPE_TYPEDBYREF
;
4767 if (class->valuetype
) {
4768 int t
= MONO_TYPE_VALUETYPE
;
4770 if (is_corlib
&& !strcmp (nspace
, "System")) {
4773 if (!strcmp (name
, "Boolean")) {
4774 t
= MONO_TYPE_BOOLEAN
;
4775 } else if (!strcmp(name
, "Byte")) {
4777 class->blittable
= TRUE
;
4781 if (!strcmp (name
, "Char")) {
4786 if (!strcmp (name
, "Double")) {
4788 class->blittable
= TRUE
;
4792 if (!strcmp (name
, "Int32")) {
4794 class->blittable
= TRUE
;
4795 } else if (!strcmp(name
, "Int16")) {
4797 class->blittable
= TRUE
;
4798 } else if (!strcmp(name
, "Int64")) {
4800 class->blittable
= TRUE
;
4801 } else if (!strcmp(name
, "IntPtr")) {
4803 class->blittable
= TRUE
;
4807 if (!strcmp (name
, "Single")) {
4809 class->blittable
= TRUE
;
4810 } else if (!strcmp(name
, "SByte")) {
4812 class->blittable
= TRUE
;
4816 if (!strcmp (name
, "UInt32")) {
4818 class->blittable
= TRUE
;
4819 } else if (!strcmp(name
, "UInt16")) {
4821 class->blittable
= TRUE
;
4822 } else if (!strcmp(name
, "UInt64")) {
4824 class->blittable
= TRUE
;
4825 } else if (!strcmp(name
, "UIntPtr")) {
4827 class->blittable
= TRUE
;
4831 if (!strcmp (name
, "TypedReference")) {
4832 t
= MONO_TYPE_TYPEDBYREF
;
4833 class->blittable
= TRUE
;
4837 if (!strcmp (name
, "Void")) {
4845 class->this_arg
.type
= class->byval_arg
.type
= t
;
4848 if (MONO_CLASS_IS_INTERFACE (class))
4849 class->interface_id
= mono_get_unique_iid (class);
4854 * COM initialization (using mono_init_com_types) is delayed until needed.
4855 * However when a [ComImport] attribute is present on a type it will trigger
4856 * the initialization. This is not a problem unless the BCL being executed
4857 * lacks the types that COM depends on (e.g. Variant on Silverlight).
4860 init_com_from_comimport (MonoClass
*class)
4862 /* we don't always allow COM initialization under the CoreCLR (e.g. Moonlight does not require it) */
4863 if ((mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR
)) {
4864 /* but some other CoreCLR user could requires it for their platform (i.e. trusted) code */
4865 if (!mono_security_core_clr_determine_platform_image (class->image
)) {
4866 /* but it can not be made available for application (i.e. user code) since all COM calls
4867 * are considered native calls. In this case we fail with a TypeLoadException (just like
4868 * Silverlight 2 does */
4869 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, NULL
);
4873 /* FIXME : we should add an extra checks to ensure COM can be initialized properly before continuing */
4874 mono_init_com_types ();
4878 * LOCKING: this assumes the loader lock is held
4881 mono_class_setup_parent (MonoClass
*class, MonoClass
*parent
)
4883 gboolean system_namespace
;
4884 gboolean is_corlib
= is_corlib_image (class->image
);
4886 system_namespace
= !strcmp (class->name_space
, "System") && is_corlib
;
4888 /* if root of the hierarchy */
4889 if (system_namespace
&& !strcmp (class->name
, "Object")) {
4890 class->parent
= NULL
;
4891 class->instance_size
= sizeof (MonoObject
);
4894 if (!strcmp (class->name
, "<Module>")) {
4895 class->parent
= NULL
;
4896 class->instance_size
= 0;
4900 if (!MONO_CLASS_IS_INTERFACE (class)) {
4901 /* Imported COM Objects always derive from __ComObject. */
4902 if (MONO_CLASS_IS_IMPORT (class)) {
4903 init_com_from_comimport (class);
4904 if (parent
== mono_defaults
.object_class
)
4905 parent
= mono_defaults
.com_object_class
;
4908 /* set the parent to something useful and safe, but mark the type as broken */
4909 parent
= mono_defaults
.object_class
;
4910 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, NULL
);
4913 class->parent
= parent
;
4915 if (parent
->generic_class
&& !parent
->name
) {
4917 * If the parent is a generic instance, we may get
4918 * called before it is fully initialized, especially
4919 * before it has its name.
4924 class->marshalbyref
= parent
->marshalbyref
;
4925 class->contextbound
= parent
->contextbound
;
4926 class->delegate
= parent
->delegate
;
4927 if (MONO_CLASS_IS_IMPORT (class))
4928 class->is_com_object
= 1;
4930 class->is_com_object
= parent
->is_com_object
;
4932 if (system_namespace
) {
4933 if (*class->name
== 'M' && !strcmp (class->name
, "MarshalByRefObject"))
4934 class->marshalbyref
= 1;
4936 if (*class->name
== 'C' && !strcmp (class->name
, "ContextBoundObject"))
4937 class->contextbound
= 1;
4939 if (*class->name
== 'D' && !strcmp (class->name
, "Delegate"))
4940 class->delegate
= 1;
4943 if (class->parent
->enumtype
|| (is_corlib_image (class->parent
->image
) && (strcmp (class->parent
->name
, "ValueType") == 0) &&
4944 (strcmp (class->parent
->name_space
, "System") == 0)))
4945 class->valuetype
= 1;
4946 if (is_corlib_image (class->parent
->image
) && ((strcmp (class->parent
->name
, "Enum") == 0) && (strcmp (class->parent
->name_space
, "System") == 0))) {
4947 class->valuetype
= class->enumtype
= 1;
4949 /*class->enumtype = class->parent->enumtype; */
4950 mono_class_setup_supertypes (class);
4952 /* initialize com types if COM interfaces are present */
4953 if (MONO_CLASS_IS_IMPORT (class))
4954 init_com_from_comimport (class);
4955 class->parent
= NULL
;
4961 * mono_class_setup_supertypes:
4964 * Build the data structure needed to make fast type checks work.
4965 * This currently sets two fields in @class:
4966 * - idepth: distance between @class and System.Object in the type
4968 * - supertypes: array of classes: each element has a class in the hierarchy
4969 * starting from @class up to System.Object
4971 * LOCKING: this assumes the loader lock is held
4974 mono_class_setup_supertypes (MonoClass
*class)
4978 if (class->supertypes
)
4981 if (class->parent
&& !class->parent
->supertypes
)
4982 mono_class_setup_supertypes (class->parent
);
4984 class->idepth
= class->parent
->idepth
+ 1;
4988 ms
= MAX (MONO_DEFAULT_SUPERTABLE_SIZE
, class->idepth
);
4989 class->supertypes
= mono_class_alloc0 (class, sizeof (MonoClass
*) * ms
);
4991 if (class->parent
) {
4992 class->supertypes
[class->idepth
- 1] = class;
4993 memcpy (class->supertypes
, class->parent
->supertypes
, class->parent
->idepth
* sizeof (gpointer
));
4995 class->supertypes
[0] = class;
5000 * mono_class_create_from_typedef:
5001 * @image: image where the token is valid
5002 * @type_token: typedef token
5004 * Create the MonoClass* representing the specified type token.
5005 * @type_token must be a TypeDef token.
5007 * FIXME: don't return NULL on failure, just the the caller figure it out.
5010 mono_class_create_from_typedef (MonoImage
*image
, guint32 type_token
)
5012 MonoTableInfo
*tt
= &image
->tables
[MONO_TABLE_TYPEDEF
];
5013 MonoClass
*class, *parent
= NULL
;
5014 guint32 cols
[MONO_TYPEDEF_SIZE
];
5015 guint32 cols_next
[MONO_TYPEDEF_SIZE
];
5016 guint tidx
= mono_metadata_token_index (type_token
);
5017 MonoGenericContext
*context
= NULL
;
5018 const char *name
, *nspace
;
5020 MonoClass
**interfaces
;
5021 guint32 field_last
, method_last
;
5022 guint32 nesting_tokeen
;
5024 if (mono_metadata_token_table (type_token
) != MONO_TABLE_TYPEDEF
|| tidx
> tt
->rows
)
5027 mono_loader_lock ();
5029 if ((class = mono_internal_hash_table_lookup (&image
->class_cache
, GUINT_TO_POINTER (type_token
)))) {
5030 mono_loader_unlock ();
5031 return class->exception_type
? NULL
: class;
5034 mono_metadata_decode_row (tt
, tidx
- 1, cols
, MONO_TYPEDEF_SIZE
);
5036 name
= mono_metadata_string_heap (image
, cols
[MONO_TYPEDEF_NAME
]);
5037 nspace
= mono_metadata_string_heap (image
, cols
[MONO_TYPEDEF_NAMESPACE
]);
5039 class = mono_image_alloc0 (image
, sizeof (MonoClass
));
5042 class->name_space
= nspace
;
5044 mono_profiler_class_event (class, MONO_PROFILE_START_LOAD
);
5046 class->image
= image
;
5047 class->type_token
= type_token
;
5048 class->flags
= cols
[MONO_TYPEDEF_FLAGS
];
5050 mono_internal_hash_table_insert (&image
->class_cache
, GUINT_TO_POINTER (type_token
), class);
5052 classes_size
+= sizeof (MonoClass
);
5055 * Check whether we're a generic type definition.
5057 class->generic_container
= mono_metadata_load_generic_params (image
, class->type_token
, NULL
);
5058 if (class->generic_container
) {
5059 class->is_generic
= 1;
5060 class->generic_container
->owner
.klass
= class;
5061 context
= &class->generic_container
->context
;
5064 if (cols
[MONO_TYPEDEF_EXTENDS
]) {
5066 guint32 parent_token
= mono_metadata_token_from_dor (cols
[MONO_TYPEDEF_EXTENDS
]);
5068 if (mono_metadata_token_table (parent_token
) == MONO_TABLE_TYPESPEC
) {
5069 /*WARNING: this must satisfy mono_metadata_type_hash*/
5070 class->this_arg
.byref
= 1;
5071 class->this_arg
.data
.klass
= class;
5072 class->this_arg
.type
= MONO_TYPE_CLASS
;
5073 class->byval_arg
.data
.klass
= class;
5074 class->byval_arg
.type
= MONO_TYPE_CLASS
;
5076 parent
= mono_class_get_full (image
, parent_token
, context
);
5078 if (parent
== NULL
){
5079 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, g_strdup ("Could not load parent type"));
5080 mono_loader_unlock ();
5081 mono_profiler_class_loaded (class, MONO_PROFILE_FAILED
);
5085 for (tmp
= parent
; tmp
; tmp
= tmp
->parent
) {
5087 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, g_strdup ("Cycle found while resolving parent"));
5088 mono_loader_unlock ();
5089 mono_profiler_class_loaded (class, MONO_PROFILE_FAILED
);
5095 mono_class_setup_parent (class, parent
);
5097 /* uses ->valuetype, which is initialized by mono_class_setup_parent above */
5098 mono_class_setup_mono_type (class);
5101 * This might access class->byval_arg for recursion generated by generic constraints,
5102 * so it has to come after setup_mono_type ().
5104 if ((nesting_tokeen
= mono_metadata_nested_in_typedef (image
, type_token
))) {
5105 class->nested_in
= mono_class_create_from_typedef (image
, nesting_tokeen
);
5106 if (!class->nested_in
) {
5107 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, g_strdup ("Could not load nestedin type"));
5108 mono_loader_unlock ();
5109 mono_profiler_class_loaded (class, MONO_PROFILE_FAILED
);
5114 if ((class->flags
& TYPE_ATTRIBUTE_STRING_FORMAT_MASK
) == TYPE_ATTRIBUTE_UNICODE_CLASS
)
5118 if ((class->flags
& TYPE_ATTRIBUTE_STRING_FORMAT_MASK
) == TYPE_ATTRIBUTE_AUTO_CLASS
)
5122 class->cast_class
= class->element_class
= class;
5124 if (!class->enumtype
) {
5125 if (!mono_metadata_interfaces_from_typedef_full (
5126 image
, type_token
, &interfaces
, &icount
, FALSE
, context
)){
5127 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, g_strdup ("Could not load interfaces"));
5128 mono_loader_unlock ();
5129 mono_profiler_class_loaded (class, MONO_PROFILE_FAILED
);
5133 class->interfaces
= interfaces
;
5134 class->interface_count
= icount
;
5135 class->interfaces_inited
= 1;
5138 /*g_print ("Load class %s\n", name);*/
5141 * Compute the field and method lists
5143 class->field
.first
= cols
[MONO_TYPEDEF_FIELD_LIST
] - 1;
5144 class->method
.first
= cols
[MONO_TYPEDEF_METHOD_LIST
] - 1;
5146 if (tt
->rows
> tidx
){
5147 mono_metadata_decode_row (tt
, tidx
, cols_next
, MONO_TYPEDEF_SIZE
);
5148 field_last
= cols_next
[MONO_TYPEDEF_FIELD_LIST
] - 1;
5149 method_last
= cols_next
[MONO_TYPEDEF_METHOD_LIST
] - 1;
5151 field_last
= image
->tables
[MONO_TABLE_FIELD
].rows
;
5152 method_last
= image
->tables
[MONO_TABLE_METHOD
].rows
;
5155 if (cols
[MONO_TYPEDEF_FIELD_LIST
] &&
5156 cols
[MONO_TYPEDEF_FIELD_LIST
] <= image
->tables
[MONO_TABLE_FIELD
].rows
)
5157 class->field
.count
= field_last
- class->field
.first
;
5159 class->field
.count
= 0;
5161 if (cols
[MONO_TYPEDEF_METHOD_LIST
] <= image
->tables
[MONO_TABLE_METHOD
].rows
)
5162 class->method
.count
= method_last
- class->method
.first
;
5164 class->method
.count
= 0;
5166 /* reserve space to store vector pointer in arrays */
5167 if (is_corlib_image (image
) && !strcmp (nspace
, "System") && !strcmp (name
, "Array")) {
5168 class->instance_size
+= 2 * sizeof (gpointer
);
5169 g_assert (class->field
.count
== 0);
5172 if (class->enumtype
) {
5173 MonoType
*enum_basetype
= mono_class_find_enum_basetype (class);
5174 if (!enum_basetype
) {
5175 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, NULL
);
5176 mono_loader_unlock ();
5177 mono_profiler_class_loaded (class, MONO_PROFILE_FAILED
);
5180 class->cast_class
= class->element_class
= mono_class_from_mono_type (enum_basetype
);
5184 * If we're a generic type definition, load the constraints.
5185 * We must do this after the class has been constructed to make certain recursive scenarios
5188 if (class->generic_container
&& !mono_metadata_load_generic_param_constraints_full (image
, type_token
, class->generic_container
)){
5189 char *class_name
= g_strdup_printf("%s.%s", class->name_space
, class->name
);
5190 char *error
= concat_two_strings_with_zero (class->image
, class_name
, class->image
->assembly_name
);
5191 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, error
);
5192 g_free (class_name
);
5193 mono_loader_unlock ();
5194 mono_profiler_class_loaded (class, MONO_PROFILE_FAILED
);
5198 if (class->image
->assembly_name
&& !strcmp (class->image
->assembly_name
, "Mono.Simd") && !strcmp (nspace
, "Mono.Simd")) {
5199 if (!strncmp (name
, "Vector", 6))
5200 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");
5203 mono_loader_unlock ();
5205 mono_profiler_class_loaded (class, MONO_PROFILE_OK
);
5210 /** is klass Nullable<T>? */
5212 mono_class_is_nullable (MonoClass
*klass
)
5214 return klass
->generic_class
!= NULL
&&
5215 klass
->generic_class
->container_class
== mono_defaults
.generic_nullable_class
;
5219 /** if klass is T? return T */
5221 mono_class_get_nullable_param (MonoClass
*klass
)
5223 g_assert (mono_class_is_nullable (klass
));
5224 return mono_class_from_mono_type (klass
->generic_class
->context
.class_inst
->type_argv
[0]);
5228 * Create the `MonoClass' for an instantiation of a generic type.
5229 * We only do this if we actually need it.
5232 mono_generic_class_get_class (MonoGenericClass
*gclass
)
5234 MonoClass
*klass
, *gklass
;
5236 mono_loader_lock ();
5237 if (gclass
->cached_class
) {
5238 mono_loader_unlock ();
5239 return gclass
->cached_class
;
5242 gclass
->cached_class
= g_malloc0 (sizeof (MonoClass
));
5243 klass
= gclass
->cached_class
;
5245 gklass
= gclass
->container_class
;
5247 if (gklass
->nested_in
) {
5249 * FIXME: the nested type context should include everything the
5250 * nesting context should have, but it may also have additional
5251 * generic parameters...
5253 klass
->nested_in
= mono_class_inflate_generic_class (gklass
->nested_in
,
5254 mono_generic_class_get_context (gclass
));
5257 klass
->name
= gklass
->name
;
5258 klass
->name_space
= gklass
->name_space
;
5260 mono_profiler_class_event (klass
, MONO_PROFILE_START_LOAD
);
5262 klass
->image
= gklass
->image
;
5263 klass
->flags
= gklass
->flags
;
5264 klass
->type_token
= gklass
->type_token
;
5265 klass
->field
.count
= gklass
->field
.count
;
5267 klass
->is_inflated
= 1;
5268 klass
->generic_class
= gclass
;
5270 klass
->this_arg
.type
= klass
->byval_arg
.type
= MONO_TYPE_GENERICINST
;
5271 klass
->this_arg
.data
.generic_class
= klass
->byval_arg
.data
.generic_class
= gclass
;
5272 klass
->this_arg
.byref
= TRUE
;
5273 klass
->enumtype
= gklass
->enumtype
;
5274 klass
->valuetype
= gklass
->valuetype
;
5276 klass
->cast_class
= klass
->element_class
= klass
;
5278 if (mono_class_is_nullable (klass
))
5279 klass
->cast_class
= klass
->element_class
= mono_class_get_nullable_param (klass
);
5282 * We're not interested in the nested classes of a generic instance.
5283 * We use the generic type definition to look for nested classes.
5286 if (gklass
->parent
) {
5287 klass
->parent
= mono_class_inflate_generic_class (gklass
->parent
, mono_generic_class_get_context (gclass
));
5291 mono_class_setup_parent (klass
, klass
->parent
);
5293 if (klass
->enumtype
) {
5294 klass
->cast_class
= gklass
->cast_class
;
5295 klass
->element_class
= gklass
->element_class
;
5298 if (gclass
->is_dynamic
) {
5301 mono_class_setup_supertypes (klass
);
5303 if (klass
->enumtype
) {
5305 * For enums, gklass->fields might not been set, but instance_size etc. is
5306 * already set in mono_reflection_create_internal_class (). For non-enums,
5307 * these will be computed normally in mono_class_layout_fields ().
5309 klass
->instance_size
= gklass
->instance_size
;
5310 klass
->sizes
.class_size
= gklass
->sizes
.class_size
;
5311 klass
->size_inited
= 1;
5315 mono_profiler_class_loaded (klass
, MONO_PROFILE_OK
);
5317 inflated_classes
++;
5318 inflated_classes_size
+= sizeof (MonoClass
);
5320 mono_loader_unlock ();
5326 make_generic_param_class (MonoGenericParam
*param
, MonoImage
*image
, gboolean is_mvar
, MonoGenericParamInfo
*pinfo
)
5328 MonoClass
*klass
, **ptr
;
5330 MonoGenericContainer
*container
= mono_generic_param_owner (param
);
5334 image
= mono_defaults
.corlib
;
5336 klass
= mono_image_alloc0 (image
, sizeof (MonoClass
));
5337 classes_size
+= sizeof (MonoClass
);
5340 klass
->name
= pinfo
->name
;
5342 int n
= mono_generic_param_num (param
);
5343 klass
->name
= mono_image_alloc0 (image
, 16);
5344 sprintf ((char*)klass
->name
, "%d", n
);
5349 MonoMethod
*omethod
= container
->owner
.method
;
5350 klass
->name_space
= (omethod
&& omethod
->klass
) ? omethod
->klass
->name_space
: "";
5352 MonoClass
*oklass
= container
->owner
.klass
;
5353 klass
->name_space
= oklass
? oklass
->name_space
: "";
5356 klass
->name_space
= "";
5359 mono_profiler_class_event (klass
, MONO_PROFILE_START_LOAD
);
5363 for (ptr
= pinfo
->constraints
; ptr
&& *ptr
; ptr
++, count
++)
5367 if ((count
> 0) && !MONO_CLASS_IS_INTERFACE (pinfo
->constraints
[0])) {
5368 klass
->parent
= pinfo
->constraints
[0];
5370 } else if (pinfo
&& pinfo
->flags
& GENERIC_PARAMETER_ATTRIBUTE_VALUE_TYPE_CONSTRAINT
)
5371 klass
->parent
= mono_class_from_name (mono_defaults
.corlib
, "System", "ValueType");
5373 klass
->parent
= mono_defaults
.object_class
;
5376 if (count
- pos
> 0) {
5377 klass
->interface_count
= count
- pos
;
5378 klass
->interfaces
= mono_image_alloc0 (image
, sizeof (MonoClass
*) * (count
- pos
));
5379 klass
->interfaces_inited
= TRUE
;
5380 for (i
= pos
; i
< count
; i
++)
5381 klass
->interfaces
[i
- pos
] = pinfo
->constraints
[i
];
5384 klass
->image
= image
;
5386 klass
->inited
= TRUE
;
5387 klass
->cast_class
= klass
->element_class
= klass
;
5388 klass
->flags
= TYPE_ATTRIBUTE_PUBLIC
;
5390 klass
->this_arg
.type
= klass
->byval_arg
.type
= is_mvar
? MONO_TYPE_MVAR
: MONO_TYPE_VAR
;
5391 klass
->this_arg
.data
.generic_param
= klass
->byval_arg
.data
.generic_param
= param
;
5392 klass
->this_arg
.byref
= TRUE
;
5394 /* We don't use type_token for VAR since only classes can use it (not arrays, pointer, VARs, etc) */
5395 klass
->sizes
.generic_param_token
= pinfo
? pinfo
->token
: 0;
5397 /*Init these fields to sane values*/
5398 klass
->min_align
= 1;
5399 klass
->instance_size
= sizeof (gpointer
);
5400 klass
->size_inited
= 1;
5402 mono_class_setup_supertypes (klass
);
5404 if (count
- pos
> 0) {
5405 mono_class_setup_vtable (klass
->parent
);
5406 g_assert (!klass
->parent
->exception_type
);
5407 setup_interface_offsets (klass
, klass
->parent
->vtable_size
);
5413 #define FAST_CACHE_SIZE 16
5414 static MonoClass
*var_cache_fast
[FAST_CACHE_SIZE
];
5415 static MonoClass
*mvar_cache_fast
[FAST_CACHE_SIZE
];
5416 static GHashTable
*var_cache_slow
;
5417 static GHashTable
*mvar_cache_slow
;
5420 get_anon_gparam_class (MonoGenericParam
*param
, gboolean is_mvar
)
5422 int n
= mono_generic_param_num (param
);
5425 if (n
< FAST_CACHE_SIZE
)
5426 return (is_mvar
? mvar_cache_fast
: var_cache_fast
) [n
];
5427 ht
= is_mvar
? mvar_cache_slow
: var_cache_slow
;
5428 return ht
? g_hash_table_lookup (ht
, GINT_TO_POINTER (n
)) : NULL
;
5432 set_anon_gparam_class (MonoGenericParam
*param
, gboolean is_mvar
, MonoClass
*klass
)
5434 int n
= mono_generic_param_num (param
);
5437 if (n
< FAST_CACHE_SIZE
) {
5438 (is_mvar
? mvar_cache_fast
: var_cache_fast
) [n
] = klass
;
5441 ht
= is_mvar
? mvar_cache_slow
: var_cache_slow
;
5443 ht
= g_hash_table_new (NULL
, NULL
);
5445 mvar_cache_slow
= ht
;
5447 var_cache_slow
= ht
;
5450 g_hash_table_insert (ht
, GINT_TO_POINTER (n
), klass
);
5454 * LOCKING: Acquires the loader lock.
5457 mono_class_from_generic_parameter (MonoGenericParam
*param
, MonoImage
*image
, gboolean is_mvar
)
5459 MonoGenericContainer
*container
= mono_generic_param_owner (param
);
5460 MonoGenericParamInfo
*pinfo
;
5463 mono_loader_lock ();
5466 pinfo
= mono_generic_param_info (param
);
5467 if (pinfo
->pklass
) {
5468 mono_loader_unlock ();
5469 return pinfo
->pklass
;
5475 klass
= get_anon_gparam_class (param
, is_mvar
);
5477 mono_loader_unlock ();
5482 if (!image
&& container
) {
5484 MonoMethod
*method
= container
->owner
.method
;
5485 image
= (method
&& method
->klass
) ? method
->klass
->image
: NULL
;
5487 MonoClass
*klass
= container
->owner
.klass
;
5488 // FIXME: 'klass' should not be null
5489 // But, monodis creates GenericContainers without associating a owner to it
5490 image
= klass
? klass
->image
: NULL
;
5494 klass
= make_generic_param_class (param
, image
, is_mvar
, pinfo
);
5496 mono_memory_barrier ();
5499 pinfo
->pklass
= klass
;
5501 set_anon_gparam_class (param
, is_mvar
, klass
);
5503 mono_loader_unlock ();
5505 /* FIXME: Should this go inside 'make_generic_param_klass'? */
5506 mono_profiler_class_loaded (klass
, MONO_PROFILE_OK
);
5512 mono_ptr_class_get (MonoType
*type
)
5515 MonoClass
*el_class
;
5519 el_class
= mono_class_from_mono_type (type
);
5520 image
= el_class
->image
;
5522 mono_loader_lock ();
5524 if (!image
->ptr_cache
)
5525 image
->ptr_cache
= g_hash_table_new (mono_aligned_addr_hash
, NULL
);
5527 if ((result
= g_hash_table_lookup (image
->ptr_cache
, el_class
))) {
5528 mono_loader_unlock ();
5531 result
= mono_image_alloc0 (image
, sizeof (MonoClass
));
5533 classes_size
+= sizeof (MonoClass
);
5535 result
->parent
= NULL
; /* no parent for PTR types */
5536 result
->name_space
= el_class
->name_space
;
5537 name
= g_strdup_printf ("%s*", el_class
->name
);
5538 result
->name
= mono_image_strdup (image
, name
);
5541 mono_profiler_class_event (result
, MONO_PROFILE_START_LOAD
);
5543 result
->image
= el_class
->image
;
5544 result
->inited
= TRUE
;
5545 result
->flags
= TYPE_ATTRIBUTE_CLASS
| (el_class
->flags
& TYPE_ATTRIBUTE_VISIBILITY_MASK
);
5546 /* Can pointers get boxed? */
5547 result
->instance_size
= sizeof (gpointer
);
5548 result
->cast_class
= result
->element_class
= el_class
;
5549 result
->blittable
= TRUE
;
5551 result
->this_arg
.type
= result
->byval_arg
.type
= MONO_TYPE_PTR
;
5552 result
->this_arg
.data
.type
= result
->byval_arg
.data
.type
= &result
->element_class
->byval_arg
;
5553 result
->this_arg
.byref
= TRUE
;
5555 mono_class_setup_supertypes (result
);
5557 g_hash_table_insert (image
->ptr_cache
, el_class
, result
);
5559 mono_loader_unlock ();
5561 mono_profiler_class_loaded (result
, MONO_PROFILE_OK
);
5567 mono_fnptr_class_get (MonoMethodSignature
*sig
)
5570 static GHashTable
*ptr_hash
= NULL
;
5572 /* FIXME: These should be allocate from a mempool as well, but which one ? */
5574 mono_loader_lock ();
5577 ptr_hash
= g_hash_table_new (mono_aligned_addr_hash
, NULL
);
5579 if ((result
= g_hash_table_lookup (ptr_hash
, sig
))) {
5580 mono_loader_unlock ();
5583 result
= g_new0 (MonoClass
, 1);
5585 result
->parent
= NULL
; /* no parent for PTR types */
5586 result
->name_space
= "System";
5587 result
->name
= "MonoFNPtrFakeClass";
5589 mono_profiler_class_event (result
, MONO_PROFILE_START_LOAD
);
5591 result
->image
= mono_defaults
.corlib
; /* need to fix... */
5592 result
->inited
= TRUE
;
5593 result
->flags
= TYPE_ATTRIBUTE_CLASS
; /* | (el_class->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK); */
5594 /* Can pointers get boxed? */
5595 result
->instance_size
= sizeof (gpointer
);
5596 result
->cast_class
= result
->element_class
= result
;
5597 result
->blittable
= TRUE
;
5599 result
->this_arg
.type
= result
->byval_arg
.type
= MONO_TYPE_FNPTR
;
5600 result
->this_arg
.data
.method
= result
->byval_arg
.data
.method
= sig
;
5601 result
->this_arg
.byref
= TRUE
;
5602 result
->blittable
= TRUE
;
5604 mono_class_setup_supertypes (result
);
5606 g_hash_table_insert (ptr_hash
, sig
, result
);
5608 mono_loader_unlock ();
5610 mono_profiler_class_loaded (result
, MONO_PROFILE_OK
);
5616 mono_class_from_mono_type (MonoType
*type
)
5618 switch (type
->type
) {
5619 case MONO_TYPE_OBJECT
:
5620 return type
->data
.klass
? type
->data
.klass
: mono_defaults
.object_class
;
5621 case MONO_TYPE_VOID
:
5622 return type
->data
.klass
? type
->data
.klass
: mono_defaults
.void_class
;
5623 case MONO_TYPE_BOOLEAN
:
5624 return type
->data
.klass
? type
->data
.klass
: mono_defaults
.boolean_class
;
5625 case MONO_TYPE_CHAR
:
5626 return type
->data
.klass
? type
->data
.klass
: mono_defaults
.char_class
;
5628 return type
->data
.klass
? type
->data
.klass
: mono_defaults
.sbyte_class
;
5630 return type
->data
.klass
? type
->data
.klass
: mono_defaults
.byte_class
;
5632 return type
->data
.klass
? type
->data
.klass
: mono_defaults
.int16_class
;
5634 return type
->data
.klass
? type
->data
.klass
: mono_defaults
.uint16_class
;
5636 return type
->data
.klass
? type
->data
.klass
: mono_defaults
.int32_class
;
5638 return type
->data
.klass
? type
->data
.klass
: mono_defaults
.uint32_class
;
5640 return type
->data
.klass
? type
->data
.klass
: mono_defaults
.int_class
;
5642 return type
->data
.klass
? type
->data
.klass
: mono_defaults
.uint_class
;
5644 return type
->data
.klass
? type
->data
.klass
: mono_defaults
.int64_class
;
5646 return type
->data
.klass
? type
->data
.klass
: mono_defaults
.uint64_class
;
5648 return type
->data
.klass
? type
->data
.klass
: mono_defaults
.single_class
;
5650 return type
->data
.klass
? type
->data
.klass
: mono_defaults
.double_class
;
5651 case MONO_TYPE_STRING
:
5652 return type
->data
.klass
? type
->data
.klass
: mono_defaults
.string_class
;
5653 case MONO_TYPE_TYPEDBYREF
:
5654 return type
->data
.klass
? type
->data
.klass
: mono_defaults
.typed_reference_class
;
5655 case MONO_TYPE_ARRAY
:
5656 return mono_bounded_array_class_get (type
->data
.array
->eklass
, type
->data
.array
->rank
, TRUE
);
5658 return mono_ptr_class_get (type
->data
.type
);
5659 case MONO_TYPE_FNPTR
:
5660 return mono_fnptr_class_get (type
->data
.method
);
5661 case MONO_TYPE_SZARRAY
:
5662 return mono_array_class_get (type
->data
.klass
, 1);
5663 case MONO_TYPE_CLASS
:
5664 case MONO_TYPE_VALUETYPE
:
5665 return type
->data
.klass
;
5666 case MONO_TYPE_GENERICINST
:
5667 return mono_generic_class_get_class (type
->data
.generic_class
);
5669 return mono_class_from_generic_parameter (type
->data
.generic_param
, NULL
, FALSE
);
5670 case MONO_TYPE_MVAR
:
5671 return mono_class_from_generic_parameter (type
->data
.generic_param
, NULL
, TRUE
);
5673 g_warning ("mono_class_from_mono_type: implement me 0x%02x\n", type
->type
);
5674 g_assert_not_reached ();
5681 * mono_type_retrieve_from_typespec
5682 * @image: context where the image is created
5683 * @type_spec: typespec token
5684 * @context: the generic context used to evaluate generic instantiations in
5687 mono_type_retrieve_from_typespec (MonoImage
*image
, guint32 type_spec
, MonoGenericContext
*context
, gboolean
*did_inflate
, MonoError
*error
)
5689 MonoType
*t
= mono_type_create_from_typespec (image
, type_spec
);
5691 mono_error_init (error
);
5692 *did_inflate
= FALSE
;
5695 char *name
= mono_class_name_from_token (image
, type_spec
);
5696 char *assembly
= mono_assembly_name_from_token (image
, type_spec
);
5697 mono_error_set_type_load_name (error
, name
, assembly
, "Could not resolve typespec token %08x", type_spec
);
5701 if (context
&& (context
->class_inst
|| context
->method_inst
)) {
5702 MonoType
*inflated
= inflate_generic_type (NULL
, t
, context
, error
);
5704 if (!mono_error_ok (error
))
5709 *did_inflate
= TRUE
;
5716 * mono_class_create_from_typespec
5717 * @image: context where the image is created
5718 * @type_spec: typespec token
5719 * @context: the generic context used to evaluate generic instantiations in
5722 mono_class_create_from_typespec (MonoImage
*image
, guint32 type_spec
, MonoGenericContext
*context
, MonoError
*error
)
5725 gboolean inflated
= FALSE
;
5726 MonoType
*t
= mono_type_retrieve_from_typespec (image
, type_spec
, context
, &inflated
, error
);
5727 if (!mono_error_ok (error
))
5729 ret
= mono_class_from_mono_type (t
);
5731 mono_metadata_free_type (t
);
5736 * mono_bounded_array_class_get:
5737 * @element_class: element class
5738 * @rank: the dimension of the array class
5739 * @bounded: whenever the array has non-zero bounds
5741 * Returns: a class object describing the array with element type @element_type and
5745 mono_bounded_array_class_get (MonoClass
*eclass
, guint32 rank
, gboolean bounded
)
5749 MonoClass
*parent
= NULL
;
5750 GSList
*list
, *rootlist
= NULL
;
5753 gboolean corlib_type
= FALSE
;
5755 g_assert (rank
<= 255);
5758 /* bounded only matters for one-dimensional arrays */
5761 image
= eclass
->image
;
5763 if (rank
== 1 && !bounded
) {
5765 * This case is very frequent not just during compilation because of calls
5766 * from mono_class_from_mono_type (), mono_array_new (),
5767 * Array:CreateInstance (), etc, so use a separate cache + a separate lock.
5769 EnterCriticalSection (&image
->szarray_cache_lock
);
5770 if (!image
->szarray_cache
)
5771 image
->szarray_cache
= g_hash_table_new (mono_aligned_addr_hash
, NULL
);
5772 class = g_hash_table_lookup (image
->szarray_cache
, eclass
);
5773 LeaveCriticalSection (&image
->szarray_cache_lock
);
5777 mono_loader_lock ();
5779 mono_loader_lock ();
5781 if (!image
->array_cache
)
5782 image
->array_cache
= g_hash_table_new (mono_aligned_addr_hash
, NULL
);
5784 if ((rootlist
= list
= g_hash_table_lookup (image
->array_cache
, eclass
))) {
5785 for (; list
; list
= list
->next
) {
5787 if ((class->rank
== rank
) && (class->byval_arg
.type
== (((rank
> 1) || bounded
) ? MONO_TYPE_ARRAY
: MONO_TYPE_SZARRAY
))) {
5788 mono_loader_unlock ();
5795 /* for the building corlib use System.Array from it */
5796 if (image
->assembly
&& image
->assembly
->dynamic
&& image
->assembly_name
&& strcmp (image
->assembly_name
, "mscorlib") == 0) {
5797 parent
= mono_class_from_name (image
, "System", "Array");
5800 parent
= mono_defaults
.array_class
;
5801 if (!parent
->inited
)
5802 mono_class_init (parent
);
5805 class = mono_image_alloc0 (image
, sizeof (MonoClass
));
5807 class->image
= image
;
5808 class->name_space
= eclass
->name_space
;
5809 nsize
= strlen (eclass
->name
);
5810 name
= g_malloc (nsize
+ 2 + rank
+ 1);
5811 memcpy (name
, eclass
->name
, nsize
);
5814 memset (name
+ nsize
+ 1, ',', rank
- 1);
5816 name
[nsize
+ rank
] = '*';
5817 name
[nsize
+ rank
+ bounded
] = ']';
5818 name
[nsize
+ rank
+ bounded
+ 1] = 0;
5819 class->name
= mono_image_strdup (image
, name
);
5822 mono_profiler_class_event (class, MONO_PROFILE_START_LOAD
);
5824 classes_size
+= sizeof (MonoClass
);
5826 class->type_token
= 0;
5827 /* all arrays are marked serializable and sealed, bug #42779 */
5828 class->flags
= TYPE_ATTRIBUTE_CLASS
| TYPE_ATTRIBUTE_SERIALIZABLE
| TYPE_ATTRIBUTE_SEALED
| TYPE_ATTRIBUTE_PUBLIC
;
5829 class->parent
= parent
;
5830 class->instance_size
= mono_class_instance_size (class->parent
);
5832 if (eclass
->enumtype
&& !mono_class_enum_basetype (eclass
)) {
5833 if (!eclass
->ref_info_handle
|| eclass
->wastypebuilder
) {
5834 g_warning ("Only incomplete TypeBuilder objects are allowed to be an enum without base_type");
5835 g_assert (eclass
->ref_info_handle
&& !eclass
->wastypebuilder
);
5837 /* element_size -1 is ok as this is not an instantitable type*/
5838 class->sizes
.element_size
= -1;
5840 class->sizes
.element_size
= mono_class_array_element_size (eclass
);
5842 mono_class_setup_supertypes (class);
5844 if (eclass
->generic_class
)
5845 mono_class_init (eclass
);
5846 if (!eclass
->size_inited
)
5847 mono_class_setup_fields (eclass
);
5848 if (eclass
->exception_type
) /*FIXME we fail the array type, but we have to let other fields be set.*/
5849 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD
, NULL
);
5851 class->has_references
= MONO_TYPE_IS_REFERENCE (&eclass
->byval_arg
) || eclass
->has_references
? TRUE
: FALSE
;
5855 if (eclass
->enumtype
)
5856 class->cast_class
= eclass
->element_class
;
5858 class->cast_class
= eclass
;
5860 switch (class->cast_class
->byval_arg
.type
) {
5862 class->cast_class
= mono_defaults
.byte_class
;
5865 class->cast_class
= mono_defaults
.int16_class
;
5868 #if SIZEOF_VOID_P == 4
5872 class->cast_class
= mono_defaults
.int32_class
;
5875 #if SIZEOF_VOID_P == 8
5879 class->cast_class
= mono_defaults
.int64_class
;
5883 class->element_class
= eclass
;
5885 if ((rank
> 1) || bounded
) {
5886 MonoArrayType
*at
= mono_image_alloc0 (image
, sizeof (MonoArrayType
));
5887 class->byval_arg
.type
= MONO_TYPE_ARRAY
;
5888 class->byval_arg
.data
.array
= at
;
5889 at
->eklass
= eclass
;
5891 /* FIXME: complete.... */
5893 class->byval_arg
.type
= MONO_TYPE_SZARRAY
;
5894 class->byval_arg
.data
.klass
= eclass
;
5896 class->this_arg
= class->byval_arg
;
5897 class->this_arg
.byref
= 1;
5902 class->generic_container
= eclass
->generic_container
;
5904 if (rank
== 1 && !bounded
) {
5905 MonoClass
*prev_class
;
5907 EnterCriticalSection (&image
->szarray_cache_lock
);
5908 prev_class
= g_hash_table_lookup (image
->szarray_cache
, eclass
);
5910 /* Someone got in before us */
5913 g_hash_table_insert (image
->szarray_cache
, eclass
, class);
5914 LeaveCriticalSection (&image
->szarray_cache_lock
);
5916 list
= g_slist_append (rootlist
, class);
5917 g_hash_table_insert (image
->array_cache
, eclass
, list
);
5920 mono_loader_unlock ();
5922 mono_profiler_class_loaded (class, MONO_PROFILE_OK
);
5928 * mono_array_class_get:
5929 * @element_class: element class
5930 * @rank: the dimension of the array class
5932 * Returns: a class object describing the array with element type @element_type and
5936 mono_array_class_get (MonoClass
*eclass
, guint32 rank
)
5938 return mono_bounded_array_class_get (eclass
, rank
, FALSE
);
5942 * mono_class_instance_size:
5945 * Returns: the size of an object instance
5948 mono_class_instance_size (MonoClass
*klass
)
5950 if (!klass
->size_inited
)
5951 mono_class_init (klass
);
5953 return klass
->instance_size
;
5957 * mono_class_min_align:
5960 * Returns: minimm alignment requirements
5963 mono_class_min_align (MonoClass
*klass
)
5965 if (!klass
->size_inited
)
5966 mono_class_init (klass
);
5968 return klass
->min_align
;
5972 * mono_class_value_size:
5975 * This function is used for value types, and return the
5976 * space and the alignment to store that kind of value object.
5978 * Returns: the size of a value of kind @klass
5981 mono_class_value_size (MonoClass
*klass
, guint32
*align
)
5985 /* fixme: check disable, because we still have external revereces to
5986 * mscorlib and Dummy Objects
5988 /*g_assert (klass->valuetype);*/
5990 size
= mono_class_instance_size (klass
) - sizeof (MonoObject
);
5993 *align
= klass
->min_align
;
5999 * mono_class_data_size:
6002 * Returns: the size of the static class data
6005 mono_class_data_size (MonoClass
*klass
)
6008 mono_class_init (klass
);
6010 /* in arrays, sizes.class_size is unioned with element_size
6011 * and arrays have no static fields
6015 return klass
->sizes
.class_size
;
6019 * Auxiliary routine to mono_class_get_field
6021 * Takes a field index instead of a field token.
6023 static MonoClassField
*
6024 mono_class_get_field_idx (MonoClass
*class, int idx
)
6026 mono_class_setup_fields_locking (class);
6027 if (class->exception_type
)
6031 if (class->image
->uncompressed_metadata
) {
6033 * class->field.first points to the FieldPtr table, while idx points into the
6034 * Field table, so we have to do a search.
6036 /*FIXME this is broken for types with multiple fields with the same name.*/
6037 const char *name
= mono_metadata_string_heap (class->image
, mono_metadata_decode_row_col (&class->image
->tables
[MONO_TABLE_FIELD
], idx
, MONO_FIELD_NAME
));
6040 for (i
= 0; i
< class->field
.count
; ++i
)
6041 if (mono_field_get_name (&class->fields
[i
]) == name
)
6042 return &class->fields
[i
];
6043 g_assert_not_reached ();
6045 if (class->field
.count
) {
6046 if ((idx
>= class->field
.first
) && (idx
< class->field
.first
+ class->field
.count
)){
6047 return &class->fields
[idx
- class->field
.first
];
6051 class = class->parent
;
6057 * mono_class_get_field:
6058 * @class: the class to lookup the field.
6059 * @field_token: the field token
6061 * Returns: A MonoClassField representing the type and offset of
6062 * the field, or a NULL value if the field does not belong to this
6066 mono_class_get_field (MonoClass
*class, guint32 field_token
)
6068 int idx
= mono_metadata_token_index (field_token
);
6070 g_assert (mono_metadata_token_code (field_token
) == MONO_TOKEN_FIELD_DEF
);
6072 return mono_class_get_field_idx (class, idx
- 1);
6076 * mono_class_get_field_from_name:
6077 * @klass: the class to lookup the field.
6078 * @name: the field name
6080 * Search the class @klass and it's parents for a field with the name @name.
6082 * Returns: the MonoClassField pointer of the named field or NULL
6085 mono_class_get_field_from_name (MonoClass
*klass
, const char *name
)
6087 return mono_class_get_field_from_name_full (klass
, name
, NULL
);
6091 * mono_class_get_field_from_name_full:
6092 * @klass: the class to lookup the field.
6093 * @name: the field name
6094 * @type: the type of the fields. This optional.
6096 * Search the class @klass and it's parents for a field with the name @name and type @type.
6098 * If @klass is an inflated generic type, the type comparison is done with the equivalent field
6099 * of its generic type definition.
6101 * Returns: the MonoClassField pointer of the named field or NULL
6104 mono_class_get_field_from_name_full (MonoClass
*klass
, const char *name
, MonoType
*type
)
6108 mono_class_setup_fields_locking (klass
);
6109 if (klass
->exception_type
)
6113 for (i
= 0; i
< klass
->field
.count
; ++i
) {
6114 MonoClassField
*field
= &klass
->fields
[i
];
6116 if (strcmp (name
, mono_field_get_name (field
)) != 0)
6120 MonoType
*field_type
= mono_metadata_get_corresponding_field_from_generic_type_definition (field
)->type
;
6121 if (!mono_metadata_type_equal_full (type
, field_type
, TRUE
))
6126 klass
= klass
->parent
;
6132 * mono_class_get_field_token:
6133 * @field: the field we need the token of
6135 * Get the token of a field. Note that the tokesn is only valid for the image
6136 * the field was loaded from. Don't use this function for fields in dynamic types.
6138 * Returns: the token representing the field in the image it was loaded from.
6141 mono_class_get_field_token (MonoClassField
*field
)
6143 MonoClass
*klass
= field
->parent
;
6146 mono_class_setup_fields_locking (klass
);
6147 if (klass
->exception_type
)
6151 for (i
= 0; i
< klass
->field
.count
; ++i
) {
6152 if (&klass
->fields
[i
] == field
) {
6153 int idx
= klass
->field
.first
+ i
+ 1;
6155 if (klass
->image
->uncompressed_metadata
)
6156 idx
= mono_metadata_translate_token_index (klass
->image
, MONO_TABLE_FIELD
, idx
);
6157 return mono_metadata_make_token (MONO_TABLE_FIELD
, idx
);
6160 klass
= klass
->parent
;
6163 g_assert_not_reached ();
6168 mono_field_get_index (MonoClassField
*field
)
6170 int index
= field
- field
->parent
->fields
;
6172 g_assert (index
>= 0 && index
< field
->parent
->field
.count
);
6178 * mono_class_get_field_default_value:
6180 * Return the default value of the field as a pointer into the metadata blob.
6183 mono_class_get_field_default_value (MonoClassField
*field
, MonoTypeEnum
*def_type
)
6186 guint32 constant_cols
[MONO_CONSTANT_SIZE
];
6188 MonoClass
*klass
= field
->parent
;
6190 g_assert (field
->type
->attrs
& FIELD_ATTRIBUTE_HAS_DEFAULT
);
6192 if (!klass
->ext
|| !klass
->ext
->field_def_values
) {
6193 mono_loader_lock ();
6194 mono_class_alloc_ext (klass
);
6195 if (!klass
->ext
->field_def_values
)
6196 klass
->ext
->field_def_values
= mono_class_alloc0 (klass
, sizeof (MonoFieldDefaultValue
) * klass
->field
.count
);
6197 mono_loader_unlock ();
6200 field_index
= mono_field_get_index (field
);
6202 if (!klass
->ext
->field_def_values
[field_index
].data
) {
6203 cindex
= mono_metadata_get_constant_index (field
->parent
->image
, mono_class_get_field_token (field
), 0);
6205 g_assert (!(field
->type
->attrs
& FIELD_ATTRIBUTE_HAS_FIELD_RVA
));
6207 mono_metadata_decode_row (&field
->parent
->image
->tables
[MONO_TABLE_CONSTANT
], cindex
- 1, constant_cols
, MONO_CONSTANT_SIZE
);
6208 klass
->ext
->field_def_values
[field_index
].def_type
= constant_cols
[MONO_CONSTANT_TYPE
];
6209 klass
->ext
->field_def_values
[field_index
].data
= (gpointer
)mono_metadata_blob_heap (field
->parent
->image
, constant_cols
[MONO_CONSTANT_VALUE
]);
6212 *def_type
= klass
->ext
->field_def_values
[field_index
].def_type
;
6213 return klass
->ext
->field_def_values
[field_index
].data
;
6217 * mono_class_get_property_default_value:
6219 * Return the default value of the field as a pointer into the metadata blob.
6222 mono_class_get_property_default_value (MonoProperty
*property
, MonoTypeEnum
*def_type
)
6225 guint32 constant_cols
[MONO_CONSTANT_SIZE
];
6226 MonoClass
*klass
= property
->parent
;
6228 g_assert (property
->attrs
& PROPERTY_ATTRIBUTE_HAS_DEFAULT
);
6229 /*We don't cache here because it is not used by C# so it's quite rare.*/
6231 cindex
= mono_metadata_get_constant_index (klass
->image
, mono_class_get_property_token (property
), 0);
6235 mono_metadata_decode_row (&klass
->image
->tables
[MONO_TABLE_CONSTANT
], cindex
- 1, constant_cols
, MONO_CONSTANT_SIZE
);
6236 *def_type
= constant_cols
[MONO_CONSTANT_TYPE
];
6237 return (gpointer
)mono_metadata_blob_heap (klass
->image
, constant_cols
[MONO_CONSTANT_VALUE
]);
6241 mono_class_get_event_token (MonoEvent
*event
)
6243 MonoClass
*klass
= event
->parent
;
6248 for (i
= 0; i
< klass
->ext
->event
.count
; ++i
) {
6249 if (&klass
->ext
->events
[i
] == event
)
6250 return mono_metadata_make_token (MONO_TABLE_EVENT
, klass
->ext
->event
.first
+ i
+ 1);
6253 klass
= klass
->parent
;
6256 g_assert_not_reached ();
6261 mono_class_get_property_from_name (MonoClass
*klass
, const char *name
)
6265 gpointer iter
= NULL
;
6266 while ((p
= mono_class_get_properties (klass
, &iter
))) {
6267 if (! strcmp (name
, p
->name
))
6270 klass
= klass
->parent
;
6276 mono_class_get_property_token (MonoProperty
*prop
)
6278 MonoClass
*klass
= prop
->parent
;
6282 gpointer iter
= NULL
;
6283 while ((p
= mono_class_get_properties (klass
, &iter
))) {
6284 if (&klass
->ext
->properties
[i
] == prop
)
6285 return mono_metadata_make_token (MONO_TABLE_PROPERTY
, klass
->ext
->property
.first
+ i
+ 1);
6289 klass
= klass
->parent
;
6292 g_assert_not_reached ();
6297 mono_class_name_from_token (MonoImage
*image
, guint32 type_token
)
6299 const char *name
, *nspace
;
6301 return g_strdup_printf ("DynamicType 0x%08x", type_token
);
6303 switch (type_token
& 0xff000000){
6304 case MONO_TOKEN_TYPE_DEF
: {
6305 guint32 cols
[MONO_TYPEDEF_SIZE
];
6306 MonoTableInfo
*tt
= &image
->tables
[MONO_TABLE_TYPEDEF
];
6307 guint tidx
= mono_metadata_token_index (type_token
);
6309 if (tidx
> tt
->rows
)
6310 return g_strdup_printf ("Invalid type token 0x%08x", type_token
);
6312 mono_metadata_decode_row (tt
, tidx
- 1, cols
, MONO_TYPEDEF_SIZE
);
6313 name
= mono_metadata_string_heap (image
, cols
[MONO_TYPEDEF_NAME
]);
6314 nspace
= mono_metadata_string_heap (image
, cols
[MONO_TYPEDEF_NAMESPACE
]);
6315 if (strlen (nspace
) == 0)
6316 return g_strdup_printf ("%s", name
);
6318 return g_strdup_printf ("%s.%s", nspace
, name
);
6321 case MONO_TOKEN_TYPE_REF
: {
6322 guint32 cols
[MONO_TYPEREF_SIZE
];
6323 MonoTableInfo
*t
= &image
->tables
[MONO_TABLE_TYPEREF
];
6324 guint tidx
= mono_metadata_token_index (type_token
);
6327 return g_strdup_printf ("Invalid type token 0x%08x", type_token
);
6328 mono_metadata_decode_row (t
, tidx
-1, cols
, MONO_TYPEREF_SIZE
);
6329 name
= mono_metadata_string_heap (image
, cols
[MONO_TYPEREF_NAME
]);
6330 nspace
= mono_metadata_string_heap (image
, cols
[MONO_TYPEREF_NAMESPACE
]);
6331 if (strlen (nspace
) == 0)
6332 return g_strdup_printf ("%s", name
);
6334 return g_strdup_printf ("%s.%s", nspace
, name
);
6337 case MONO_TOKEN_TYPE_SPEC
:
6338 return g_strdup_printf ("Typespec 0x%08x", type_token
);
6340 return g_strdup_printf ("Invalid type token 0x%08x", type_token
);
6345 mono_assembly_name_from_token (MonoImage
*image
, guint32 type_token
)
6348 return g_strdup_printf ("DynamicAssembly %s", image
->name
);
6350 switch (type_token
& 0xff000000){
6351 case MONO_TOKEN_TYPE_DEF
:
6352 return mono_stringify_assembly_name (&image
->assembly
->aname
);
6354 case MONO_TOKEN_TYPE_REF
: {
6355 MonoAssemblyName aname
;
6356 guint32 cols
[MONO_TYPEREF_SIZE
];
6357 MonoTableInfo
*t
= &image
->tables
[MONO_TABLE_TYPEREF
];
6358 guint32 idx
= mono_metadata_token_index (type_token
);
6361 return g_strdup_printf ("Invalid type token 0x%08x", type_token
);
6363 mono_metadata_decode_row (t
, idx
-1, cols
, MONO_TYPEREF_SIZE
);
6365 idx
= cols
[MONO_TYPEREF_SCOPE
] >> MONO_RESOLTION_SCOPE_BITS
;
6366 switch (cols
[MONO_TYPEREF_SCOPE
] & MONO_RESOLTION_SCOPE_MASK
) {
6367 case MONO_RESOLTION_SCOPE_MODULE
:
6369 return g_strdup ("");
6370 case MONO_RESOLTION_SCOPE_MODULEREF
:
6372 return g_strdup ("");
6373 case MONO_RESOLTION_SCOPE_TYPEREF
:
6375 return g_strdup ("");
6376 case MONO_RESOLTION_SCOPE_ASSEMBLYREF
:
6377 mono_assembly_get_assemblyref (image
, idx
- 1, &aname
);
6378 return mono_stringify_assembly_name (&aname
);
6380 g_assert_not_reached ();
6384 case MONO_TOKEN_TYPE_SPEC
:
6386 return g_strdup ("");
6388 g_assert_not_reached ();
6395 * mono_class_get_full:
6396 * @image: the image where the class resides
6397 * @type_token: the token for the class
6398 * @context: the generic context used to evaluate generic instantiations in
6400 * Returns: the MonoClass that represents @type_token in @image
6403 mono_class_get_full (MonoImage
*image
, guint32 type_token
, MonoGenericContext
*context
)
6406 MonoClass
*class = NULL
;
6408 if (image
->dynamic
) {
6409 int table
= mono_metadata_token_table (type_token
);
6411 if (table
!= MONO_TABLE_TYPEDEF
&& table
!= MONO_TABLE_TYPEREF
&& table
!= MONO_TABLE_TYPESPEC
) {
6412 mono_loader_set_error_bad_image (g_strdup ("Bad type token."));
6415 return mono_lookup_dynamic_token (image
, type_token
, context
);
6418 switch (type_token
& 0xff000000){
6419 case MONO_TOKEN_TYPE_DEF
:
6420 class = mono_class_create_from_typedef (image
, type_token
);
6422 case MONO_TOKEN_TYPE_REF
:
6423 class = mono_class_from_typeref (image
, type_token
);
6425 case MONO_TOKEN_TYPE_SPEC
:
6426 class = mono_class_create_from_typespec (image
, type_token
, context
, &error
);
6427 if (!mono_error_ok (&error
)) {
6428 /*FIXME don't swallow the error message*/
6429 mono_error_cleanup (&error
);
6433 g_warning ("unknown token type %x", type_token
& 0xff000000);
6434 g_assert_not_reached ();
6438 char *name
= mono_class_name_from_token (image
, type_token
);
6439 char *assembly
= mono_assembly_name_from_token (image
, type_token
);
6440 mono_loader_set_error_type_load (name
, assembly
);
6450 * mono_type_get_full:
6451 * @image: the image where the type resides
6452 * @type_token: the token for the type
6453 * @context: the generic context used to evaluate generic instantiations in
6455 * This functions exists to fullfill the fact that sometimes it's desirable to have access to the
6457 * Returns: the MonoType that represents @type_token in @image
6460 mono_type_get_full (MonoImage
*image
, guint32 type_token
, MonoGenericContext
*context
)
6463 MonoType
*type
= NULL
;
6464 gboolean inflated
= FALSE
;
6466 //FIXME: this will not fix the very issue for which mono_type_get_full exists -but how to do it then?
6468 return mono_class_get_type (mono_lookup_dynamic_token (image
, type_token
, context
));
6470 if ((type_token
& 0xff000000) != MONO_TOKEN_TYPE_SPEC
) {
6471 MonoClass
*class = mono_class_get_full (image
, type_token
, context
);
6472 return class ? mono_class_get_type (class) : NULL
;
6475 type
= mono_type_retrieve_from_typespec (image
, type_token
, context
, &inflated
, &error
);
6477 if (!mono_error_ok (&error
)) {
6478 /*FIXME don't swalloc the error message.*/
6479 char *name
= mono_class_name_from_token (image
, type_token
);
6480 char *assembly
= mono_assembly_name_from_token (image
, type_token
);
6482 g_warning ("Error loading type %s from %s due to %s", name
, assembly
, mono_error_get_message (&error
));
6484 mono_error_cleanup (&error
);
6485 mono_loader_set_error_type_load (name
, assembly
);
6490 MonoType
*tmp
= type
;
6491 type
= mono_class_get_type (mono_class_from_mono_type (type
));
6492 /* FIXME: This is a workaround fo the fact that a typespec token sometimes reference to the generic type definition.
6493 * A MonoClass::byval_arg of a generic type definion has type CLASS.
6494 * Some parts of mono create a GENERICINST to reference a generic type definition and this generates confict with byval_arg.
6496 * The long term solution is to chaise this places and make then set MonoType::type correctly.
6498 if (type
->type
!= tmp
->type
)
6501 mono_metadata_free_type (tmp
);
6508 mono_class_get (MonoImage
*image
, guint32 type_token
)
6510 return mono_class_get_full (image
, type_token
, NULL
);
6514 * mono_image_init_name_cache:
6516 * Initializes the class name cache stored in image->name_cache.
6518 * LOCKING: Acquires the corresponding image lock.
6521 mono_image_init_name_cache (MonoImage
*image
)
6523 MonoTableInfo
*t
= &image
->tables
[MONO_TABLE_TYPEDEF
];
6524 guint32 cols
[MONO_TYPEDEF_SIZE
];
6527 guint32 i
, visib
, nspace_index
;
6528 GHashTable
*name_cache2
, *nspace_table
;
6530 mono_image_lock (image
);
6532 if (image
->name_cache
) {
6533 mono_image_unlock (image
);
6537 image
->name_cache
= g_hash_table_new (g_str_hash
, g_str_equal
);
6539 if (image
->dynamic
) {
6540 mono_image_unlock (image
);
6544 /* Temporary hash table to avoid lookups in the nspace_table */
6545 name_cache2
= g_hash_table_new (NULL
, NULL
);
6547 for (i
= 1; i
<= t
->rows
; ++i
) {
6548 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_TYPEDEF_SIZE
);
6549 visib
= cols
[MONO_TYPEDEF_FLAGS
] & TYPE_ATTRIBUTE_VISIBILITY_MASK
;
6551 * Nested types are accessed from the nesting name. We use the fact that nested types use different visibility flags
6552 * than toplevel types, thus avoiding the need to grovel through the NESTED_TYPE table
6554 if (visib
>= TYPE_ATTRIBUTE_NESTED_PUBLIC
&& visib
<= TYPE_ATTRIBUTE_NESTED_FAM_OR_ASSEM
)
6556 name
= mono_metadata_string_heap (image
, cols
[MONO_TYPEDEF_NAME
]);
6557 nspace
= mono_metadata_string_heap (image
, cols
[MONO_TYPEDEF_NAMESPACE
]);
6559 nspace_index
= cols
[MONO_TYPEDEF_NAMESPACE
];
6560 nspace_table
= g_hash_table_lookup (name_cache2
, GUINT_TO_POINTER (nspace_index
));
6561 if (!nspace_table
) {
6562 nspace_table
= g_hash_table_new (g_str_hash
, g_str_equal
);
6563 g_hash_table_insert (image
->name_cache
, (char*)nspace
, nspace_table
);
6564 g_hash_table_insert (name_cache2
, GUINT_TO_POINTER (nspace_index
),
6567 g_hash_table_insert (nspace_table
, (char *) name
, GUINT_TO_POINTER (i
));
6570 /* Load type names from EXPORTEDTYPES table */
6572 MonoTableInfo
*t
= &image
->tables
[MONO_TABLE_EXPORTEDTYPE
];
6573 guint32 cols
[MONO_EXP_TYPE_SIZE
];
6576 for (i
= 0; i
< t
->rows
; ++i
) {
6577 mono_metadata_decode_row (t
, i
, cols
, MONO_EXP_TYPE_SIZE
);
6578 name
= mono_metadata_string_heap (image
, cols
[MONO_EXP_TYPE_NAME
]);
6579 nspace
= mono_metadata_string_heap (image
, cols
[MONO_EXP_TYPE_NAMESPACE
]);
6581 nspace_index
= cols
[MONO_EXP_TYPE_NAMESPACE
];
6582 nspace_table
= g_hash_table_lookup (name_cache2
, GUINT_TO_POINTER (nspace_index
));
6583 if (!nspace_table
) {
6584 nspace_table
= g_hash_table_new (g_str_hash
, g_str_equal
);
6585 g_hash_table_insert (image
->name_cache
, (char*)nspace
, nspace_table
);
6586 g_hash_table_insert (name_cache2
, GUINT_TO_POINTER (nspace_index
),
6589 g_hash_table_insert (nspace_table
, (char *) name
, GUINT_TO_POINTER (mono_metadata_make_token (MONO_TABLE_EXPORTEDTYPE
, i
+ 1)));
6593 g_hash_table_destroy (name_cache2
);
6594 mono_image_unlock (image
);
6597 /*FIXME Only dynamic assemblies should allow this operation.*/
6599 mono_image_add_to_name_cache (MonoImage
*image
, const char *nspace
,
6600 const char *name
, guint32 index
)
6602 GHashTable
*nspace_table
;
6603 GHashTable
*name_cache
;
6606 mono_image_lock (image
);
6608 if (!image
->name_cache
)
6609 mono_image_init_name_cache (image
);
6611 name_cache
= image
->name_cache
;
6612 if (!(nspace_table
= g_hash_table_lookup (name_cache
, nspace
))) {
6613 nspace_table
= g_hash_table_new (g_str_hash
, g_str_equal
);
6614 g_hash_table_insert (name_cache
, (char *)nspace
, (char *)nspace_table
);
6617 if ((old_index
= GPOINTER_TO_UINT (g_hash_table_lookup (nspace_table
, (char*) name
))))
6618 g_error ("overrwritting old token %x on image %s for type %s::%s", old_index
, image
->name
, nspace
, name
);
6620 g_hash_table_insert (nspace_table
, (char *) name
, GUINT_TO_POINTER (index
));
6622 mono_image_unlock (image
);
6631 find_nocase (gpointer key
, gpointer value
, gpointer user_data
)
6633 char *name
= (char*)key
;
6634 FindUserData
*data
= (FindUserData
*)user_data
;
6636 if (!data
->value
&& (mono_utf8_strcasecmp (name
, (char*)data
->key
) == 0))
6637 data
->value
= value
;
6641 * mono_class_from_name_case:
6642 * @image: The MonoImage where the type is looked up in
6643 * @name_space: the type namespace
6644 * @name: the type short name.
6646 * Obtains a MonoClass with a given namespace and a given name which
6647 * is located in the given MonoImage. The namespace and name
6648 * lookups are case insensitive.
6651 mono_class_from_name_case (MonoImage
*image
, const char* name_space
, const char *name
)
6653 MonoTableInfo
*t
= &image
->tables
[MONO_TABLE_TYPEDEF
];
6654 guint32 cols
[MONO_TYPEDEF_SIZE
];
6659 if (image
->dynamic
) {
6661 FindUserData user_data
;
6663 mono_image_lock (image
);
6665 if (!image
->name_cache
)
6666 mono_image_init_name_cache (image
);
6668 user_data
.key
= name_space
;
6669 user_data
.value
= NULL
;
6670 g_hash_table_foreach (image
->name_cache
, find_nocase
, &user_data
);
6672 if (user_data
.value
) {
6673 GHashTable
*nspace_table
= (GHashTable
*)user_data
.value
;
6675 user_data
.key
= name
;
6676 user_data
.value
= NULL
;
6678 g_hash_table_foreach (nspace_table
, find_nocase
, &user_data
);
6680 if (user_data
.value
)
6681 token
= GPOINTER_TO_UINT (user_data
.value
);
6684 mono_image_unlock (image
);
6687 return mono_class_get (image
, MONO_TOKEN_TYPE_DEF
| token
);
6693 /* add a cache if needed */
6694 for (i
= 1; i
<= t
->rows
; ++i
) {
6695 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_TYPEDEF_SIZE
);
6696 visib
= cols
[MONO_TYPEDEF_FLAGS
] & TYPE_ATTRIBUTE_VISIBILITY_MASK
;
6698 * Nested types are accessed from the nesting name. We use the fact that nested types use different visibility flags
6699 * than toplevel types, thus avoiding the need to grovel through the NESTED_TYPE table
6701 if (visib
>= TYPE_ATTRIBUTE_NESTED_PUBLIC
&& visib
<= TYPE_ATTRIBUTE_NESTED_FAM_OR_ASSEM
)
6703 n
= mono_metadata_string_heap (image
, cols
[MONO_TYPEDEF_NAME
]);
6704 nspace
= mono_metadata_string_heap (image
, cols
[MONO_TYPEDEF_NAMESPACE
]);
6705 if (mono_utf8_strcasecmp (n
, name
) == 0 && mono_utf8_strcasecmp (nspace
, name_space
) == 0)
6706 return mono_class_get (image
, MONO_TOKEN_TYPE_DEF
| i
);
6712 return_nested_in (MonoClass
*class, char *nested
)
6715 char *s
= strchr (nested
, '/');
6716 gpointer iter
= NULL
;
6723 while ((found
= mono_class_get_nested_types (class, &iter
))) {
6724 if (strcmp (found
->name
, nested
) == 0) {
6726 return return_nested_in (found
, s
);
6734 search_modules (MonoImage
*image
, const char *name_space
, const char *name
)
6736 MonoTableInfo
*file_table
= &image
->tables
[MONO_TABLE_FILE
];
6737 MonoImage
*file_image
;
6742 * The EXPORTEDTYPES table only contains public types, so have to search the
6744 * Note: image->modules contains the contents of the MODULEREF table, while
6745 * the real module list is in the FILE table.
6747 for (i
= 0; i
< file_table
->rows
; i
++) {
6748 guint32 cols
[MONO_FILE_SIZE
];
6749 mono_metadata_decode_row (file_table
, i
, cols
, MONO_FILE_SIZE
);
6750 if (cols
[MONO_FILE_FLAGS
] == FILE_CONTAINS_NO_METADATA
)
6753 file_image
= mono_image_load_file_for_image (image
, i
+ 1);
6755 class = mono_class_from_name (file_image
, name_space
, name
);
6765 * mono_class_from_name:
6766 * @image: The MonoImage where the type is looked up in
6767 * @name_space: the type namespace
6768 * @name: the type short name.
6770 * Obtains a MonoClass with a given namespace and a given name which
6771 * is located in the given MonoImage.
6774 mono_class_from_name (MonoImage
*image
, const char* name_space
, const char *name
)
6776 GHashTable
*nspace_table
;
6777 MonoImage
*loaded_image
;
6784 if ((nested
= strchr (name
, '/'))) {
6785 int pos
= nested
- name
;
6786 int len
= strlen (name
);
6789 memcpy (buf
, name
, len
+ 1);
6791 nested
= buf
+ pos
+ 1;
6795 if (get_class_from_name
) {
6796 gboolean res
= get_class_from_name (image
, name_space
, name
, &class);
6799 class = search_modules (image
, name_space
, name
);
6801 return class ? return_nested_in (class, nested
) : NULL
;
6807 mono_image_lock (image
);
6809 if (!image
->name_cache
)
6810 mono_image_init_name_cache (image
);
6812 nspace_table
= g_hash_table_lookup (image
->name_cache
, name_space
);
6815 token
= GPOINTER_TO_UINT (g_hash_table_lookup (nspace_table
, name
));
6817 mono_image_unlock (image
);
6819 if (!token
&& image
->dynamic
&& image
->modules
) {
6820 /* Search modules as well */
6821 for (i
= 0; i
< image
->module_count
; ++i
) {
6822 MonoImage
*module
= image
->modules
[i
];
6824 class = mono_class_from_name (module
, name_space
, name
);
6831 class = search_modules (image
, name_space
, name
);
6839 if (mono_metadata_token_table (token
) == MONO_TABLE_EXPORTEDTYPE
) {
6840 MonoTableInfo
*t
= &image
->tables
[MONO_TABLE_EXPORTEDTYPE
];
6841 guint32 cols
[MONO_EXP_TYPE_SIZE
];
6844 idx
= mono_metadata_token_index (token
);
6846 mono_metadata_decode_row (t
, idx
- 1, cols
, MONO_EXP_TYPE_SIZE
);
6848 impl
= cols
[MONO_EXP_TYPE_IMPLEMENTATION
];
6849 if ((impl
& MONO_IMPLEMENTATION_MASK
) == MONO_IMPLEMENTATION_FILE
) {
6850 loaded_image
= mono_assembly_load_module (image
->assembly
, impl
>> MONO_IMPLEMENTATION_BITS
);
6853 class = mono_class_from_name (loaded_image
, name_space
, name
);
6855 return return_nested_in (class, nested
);
6857 } else if ((impl
& MONO_IMPLEMENTATION_MASK
) == MONO_IMPLEMENTATION_ASSEMBLYREF
) {
6858 guint32 assembly_idx
;
6860 assembly_idx
= impl
>> MONO_IMPLEMENTATION_BITS
;
6862 mono_assembly_load_reference (image
, assembly_idx
- 1);
6863 g_assert (image
->references
[assembly_idx
- 1]);
6864 if (image
->references
[assembly_idx
- 1] == (gpointer
)-1)
6867 /* FIXME: Cycle detection */
6868 return mono_class_from_name (image
->references
[assembly_idx
- 1]->image
, name_space
, name
);
6870 g_error ("not yet implemented");
6874 token
= MONO_TOKEN_TYPE_DEF
| token
;
6876 class = mono_class_get (image
, token
);
6878 return return_nested_in (class, nested
);
6882 /*FIXME test for interfaces with variant generic arguments*/
6884 mono_class_is_subclass_of (MonoClass
*klass
, MonoClass
*klassc
,
6885 gboolean check_interfaces
)
6887 g_assert (klassc
->idepth
> 0);
6888 if (check_interfaces
&& MONO_CLASS_IS_INTERFACE (klassc
) && !MONO_CLASS_IS_INTERFACE (klass
)) {
6889 if (MONO_CLASS_IMPLEMENTS_INTERFACE (klass
, klassc
->interface_id
))
6891 } else if (check_interfaces
&& MONO_CLASS_IS_INTERFACE (klassc
) && MONO_CLASS_IS_INTERFACE (klass
)) {
6894 for (i
= 0; i
< klass
->interface_count
; i
++) {
6895 MonoClass
*ic
= klass
->interfaces
[i
];
6900 if (!MONO_CLASS_IS_INTERFACE (klass
) && mono_class_has_parent (klass
, klassc
))
6905 * MS.NET thinks interfaces are a subclass of Object, so we think it as
6908 if (klassc
== mono_defaults
.object_class
)
6915 mono_class_has_variant_generic_params (MonoClass
*klass
)
6918 MonoGenericContainer
*container
;
6920 if (!klass
->generic_class
)
6923 container
= klass
->generic_class
->container_class
->generic_container
;
6925 for (i
= 0; i
< container
->type_argc
; ++i
)
6926 if (mono_generic_container_get_param_info (container
, i
)->flags
& (MONO_GEN_PARAM_VARIANT
|MONO_GEN_PARAM_COVARIANT
))
6933 * @container the generic container from the GTD
6934 * @klass: the class to be assigned to
6935 * @oklass: the source class
6937 * Both klass and oklass must be instances of the same generic interface.
6938 * Return true if @klass can be assigned to a @klass variable
6941 mono_class_is_variant_compatible (MonoClass
*klass
, MonoClass
*oklass
)
6944 MonoType
**klass_argv
, **oklass_argv
;
6945 MonoClass
*klass_gtd
= mono_class_get_generic_type_definition (klass
);
6946 MonoGenericContainer
*container
= klass_gtd
->generic_container
;
6948 /*Viable candidates are instances of the same generic interface*/
6949 if (mono_class_get_generic_type_definition (oklass
) != klass_gtd
)
6952 klass_argv
= &klass
->generic_class
->context
.class_inst
->type_argv
[0];
6953 oklass_argv
= &oklass
->generic_class
->context
.class_inst
->type_argv
[0];
6955 for (j
= 0; j
< container
->type_argc
; ++j
) {
6956 MonoClass
*param1_class
= mono_class_from_mono_type (klass_argv
[j
]);
6957 MonoClass
*param2_class
= mono_class_from_mono_type (oklass_argv
[j
]);
6959 if (param1_class
->valuetype
!= param2_class
->valuetype
)
6963 * The _VARIANT and _COVARIANT constants should read _COVARIANT and
6964 * _CONTRAVARIANT, but they are in a public header so we can't fix it.
6966 if (param1_class
!= param2_class
) {
6967 if (mono_generic_container_get_param_info (container
, j
)->flags
& MONO_GEN_PARAM_VARIANT
) {
6968 if (!mono_class_is_assignable_from (param1_class
, param2_class
))
6970 } else if (mono_generic_container_get_param_info (container
, j
)->flags
& MONO_GEN_PARAM_COVARIANT
) {
6971 if (!mono_class_is_assignable_from (param2_class
, param1_class
))
6981 * mono_class_is_assignable_from:
6982 * @klass: the class to be assigned to
6983 * @oklass: the source class
6985 * Return: true if an instance of object oklass can be assigned to an
6986 * instance of object @klass
6989 mono_class_is_assignable_from (MonoClass
*klass
, MonoClass
*oklass
)
6992 mono_class_init (klass
);
6994 if (!oklass
->inited
)
6995 mono_class_init (oklass
);
6997 if ((klass
->byval_arg
.type
== MONO_TYPE_VAR
) || (klass
->byval_arg
.type
== MONO_TYPE_MVAR
))
6998 return klass
== oklass
;
7000 if (MONO_CLASS_IS_INTERFACE (klass
)) {
7001 if ((oklass
->byval_arg
.type
== MONO_TYPE_VAR
) || (oklass
->byval_arg
.type
== MONO_TYPE_MVAR
))
7004 /* interface_offsets might not be set for dynamic classes */
7005 if (oklass
->ref_info_handle
&& !oklass
->interface_bitmap
)
7007 * oklass might be a generic type parameter but they have
7008 * interface_offsets set.
7010 return mono_reflection_call_is_assignable_to (oklass
, klass
);
7011 if (!oklass
->interface_bitmap
)
7012 /* Happens with generic instances of not-yet created dynamic types */
7014 if (MONO_CLASS_IMPLEMENTS_INTERFACE (oklass
, klass
->interface_id
))
7017 if (mono_class_has_variant_generic_params (klass
)) {
7020 mono_class_setup_interfaces (oklass
, &error
);
7021 if (!mono_error_ok (&error
)) {
7022 mono_error_cleanup (&error
);
7026 /*klass is a generic variant interface, We need to extract from oklass a list of ifaces which are viable candidates.*/
7027 for (i
= 0; i
< oklass
->interface_offsets_count
; ++i
) {
7028 MonoClass
*iface
= oklass
->interfaces_packed
[i
];
7030 if (mono_class_is_variant_compatible (klass
, iface
))
7035 } else if (klass
->delegate
) {
7036 if (mono_class_has_variant_generic_params (klass
) && mono_class_is_variant_compatible (klass
, oklass
))
7038 }else if (klass
->rank
) {
7039 MonoClass
*eclass
, *eoclass
;
7041 if (oklass
->rank
!= klass
->rank
)
7044 /* vectors vs. one dimensional arrays */
7045 if (oklass
->byval_arg
.type
!= klass
->byval_arg
.type
)
7048 eclass
= klass
->cast_class
;
7049 eoclass
= oklass
->cast_class
;
7052 * a is b does not imply a[] is b[] when a is a valuetype, and
7053 * b is a reference type.
7056 if (eoclass
->valuetype
) {
7057 if ((eclass
== mono_defaults
.enum_class
) ||
7058 (eclass
== mono_defaults
.enum_class
->parent
) ||
7059 (eclass
== mono_defaults
.object_class
))
7063 return mono_class_is_assignable_from (klass
->cast_class
, oklass
->cast_class
);
7064 } else if (mono_class_is_nullable (klass
)) {
7065 if (mono_class_is_nullable (oklass
))
7066 return mono_class_is_assignable_from (klass
->cast_class
, oklass
->cast_class
);
7068 return mono_class_is_assignable_from (klass
->cast_class
, oklass
);
7069 } else if (klass
== mono_defaults
.object_class
)
7072 return mono_class_has_parent (oklass
, klass
);
7075 /*Check if @oklass is variant compatible with @klass.*/
7077 mono_class_is_variant_compatible_slow (MonoClass
*klass
, MonoClass
*oklass
)
7080 MonoType
**klass_argv
, **oklass_argv
;
7081 MonoClass
*klass_gtd
= mono_class_get_generic_type_definition (klass
);
7082 MonoGenericContainer
*container
= klass_gtd
->generic_container
;
7084 /*Viable candidates are instances of the same generic interface*/
7085 if (mono_class_get_generic_type_definition (oklass
) != klass_gtd
)
7088 klass_argv
= &klass
->generic_class
->context
.class_inst
->type_argv
[0];
7089 oklass_argv
= &oklass
->generic_class
->context
.class_inst
->type_argv
[0];
7091 for (j
= 0; j
< container
->type_argc
; ++j
) {
7092 MonoClass
*param1_class
= mono_class_from_mono_type (klass_argv
[j
]);
7093 MonoClass
*param2_class
= mono_class_from_mono_type (oklass_argv
[j
]);
7095 if (param1_class
->valuetype
!= param2_class
->valuetype
)
7099 * The _VARIANT and _COVARIANT constants should read _COVARIANT and
7100 * _CONTRAVARIANT, but they are in a public header so we can't fix it.
7102 if (param1_class
!= param2_class
) {
7103 if (mono_generic_container_get_param_info (container
, j
)->flags
& MONO_GEN_PARAM_VARIANT
) {
7104 if (!mono_class_is_assignable_from_slow (param1_class
, param2_class
))
7106 } else if (mono_generic_container_get_param_info (container
, j
)->flags
& MONO_GEN_PARAM_COVARIANT
) {
7107 if (!mono_class_is_assignable_from_slow (param2_class
, param1_class
))
7115 /*Check if @candidate implements the interface @target*/
7117 mono_class_implement_interface_slow (MonoClass
*target
, MonoClass
*candidate
)
7121 gboolean is_variant
= mono_class_has_variant_generic_params (target
);
7123 if (is_variant
&& MONO_CLASS_IS_INTERFACE (candidate
)) {
7124 if (mono_class_is_variant_compatible_slow (target
, candidate
))
7129 if (candidate
== target
)
7132 /*A TypeBuilder can have more interfaces on tb->interfaces than on candidate->interfaces*/
7133 if (candidate
->image
->dynamic
&& !candidate
->wastypebuilder
) {
7134 MonoReflectionTypeBuilder
*tb
= mono_class_get_ref_info (candidate
);
7136 if (tb
&& tb
->interfaces
) {
7137 for (j
= mono_array_length (tb
->interfaces
) - 1; j
>= 0; --j
) {
7138 MonoReflectionType
*iface
= mono_array_get (tb
->interfaces
, MonoReflectionType
*, j
);
7139 MonoClass
*iface_class
= mono_class_from_mono_type (iface
->type
);
7140 if (iface_class
== target
)
7142 if (is_variant
&& mono_class_is_variant_compatible_slow (target
, iface_class
))
7144 if (mono_class_implement_interface_slow (target
, iface_class
))
7149 /*setup_interfaces don't mono_class_init anything*/
7150 mono_class_setup_interfaces (candidate
, &error
);
7151 if (!mono_error_ok (&error
)) {
7152 mono_error_cleanup (&error
);
7156 for (i
= 0; i
< candidate
->interface_count
; ++i
) {
7157 if (candidate
->interfaces
[i
] == target
)
7160 if (is_variant
&& mono_class_is_variant_compatible_slow (target
, candidate
->interfaces
[i
]))
7163 if (mono_class_implement_interface_slow (target
, candidate
->interfaces
[i
]))
7167 candidate
= candidate
->parent
;
7168 } while (candidate
);
7174 * Check if @oklass can be assigned to @klass.
7175 * This function does the same as mono_class_is_assignable_from but is safe to be used from mono_class_init context.
7178 mono_class_is_assignable_from_slow (MonoClass
*target
, MonoClass
*candidate
)
7180 if (candidate
== target
)
7182 if (target
== mono_defaults
.object_class
)
7185 /*setup_supertypes don't mono_class_init anything */
7186 mono_class_setup_supertypes (candidate
);
7187 mono_class_setup_supertypes (target
);
7189 if (mono_class_has_parent (candidate
, target
))
7192 /*If target is not an interface there is no need to check them.*/
7193 if (MONO_CLASS_IS_INTERFACE (target
))
7194 return mono_class_implement_interface_slow (target
, candidate
);
7196 if (target
->delegate
&& mono_class_has_variant_generic_params (target
))
7197 return mono_class_is_variant_compatible (target
, candidate
);
7199 /*FIXME properly handle nullables and arrays */
7205 * mono_class_get_cctor:
7206 * @klass: A MonoClass pointer
7208 * Returns: the static constructor of @klass if it exists, NULL otherwise.
7211 mono_class_get_cctor (MonoClass
*klass
)
7213 MonoCachedClassInfo cached_info
;
7215 if (klass
->image
->dynamic
) {
7217 * has_cctor is not set for these classes because mono_class_init () is
7220 return mono_class_get_method_from_name_flags (klass
, ".cctor", -1, METHOD_ATTRIBUTE_SPECIAL_NAME
);
7223 if (!klass
->has_cctor
)
7226 if (mono_class_get_cached_class_info (klass
, &cached_info
))
7227 return mono_get_method (klass
->image
, cached_info
.cctor_token
, klass
);
7229 if (klass
->generic_class
&& !klass
->methods
)
7230 return mono_class_get_inflated_method (klass
, mono_class_get_cctor (klass
->generic_class
->container_class
));
7232 return mono_class_get_method_from_name_flags (klass
, ".cctor", -1, METHOD_ATTRIBUTE_SPECIAL_NAME
);
7236 * mono_class_get_finalizer:
7237 * @klass: The MonoClass pointer
7239 * Returns: the finalizer method of @klass if it exists, NULL otherwise.
7242 mono_class_get_finalizer (MonoClass
*klass
)
7244 MonoCachedClassInfo cached_info
;
7247 mono_class_init (klass
);
7248 if (!klass
->has_finalize
)
7251 if (mono_class_get_cached_class_info (klass
, &cached_info
))
7252 return mono_get_method (cached_info
.finalize_image
, cached_info
.finalize_token
, NULL
);
7254 mono_class_setup_vtable (klass
);
7255 return klass
->vtable
[finalize_slot
];
7260 * mono_class_needs_cctor_run:
7261 * @klass: the MonoClass pointer
7262 * @caller: a MonoMethod describing the caller
7264 * Determines whenever the class has a static constructor and whenever it
7265 * needs to be called when executing CALLER.
7268 mono_class_needs_cctor_run (MonoClass
*klass
, MonoMethod
*caller
)
7272 method
= mono_class_get_cctor (klass
);
7274 return (method
== caller
) ? FALSE
: TRUE
;
7280 * mono_class_array_element_size:
7283 * Returns: the number of bytes an element of type @klass
7284 * uses when stored into an array.
7287 mono_class_array_element_size (MonoClass
*klass
)
7289 MonoType
*type
= &klass
->byval_arg
;
7292 switch (type
->type
) {
7295 case MONO_TYPE_BOOLEAN
:
7299 case MONO_TYPE_CHAR
:
7308 case MONO_TYPE_CLASS
:
7309 case MONO_TYPE_STRING
:
7310 case MONO_TYPE_OBJECT
:
7311 case MONO_TYPE_SZARRAY
:
7312 case MONO_TYPE_ARRAY
:
7314 case MONO_TYPE_MVAR
:
7315 return sizeof (gpointer
);
7320 case MONO_TYPE_VALUETYPE
:
7321 if (type
->data
.klass
->enumtype
) {
7322 type
= mono_class_enum_basetype (type
->data
.klass
);
7323 klass
= klass
->element_class
;
7326 return mono_class_instance_size (klass
) - sizeof (MonoObject
);
7327 case MONO_TYPE_GENERICINST
:
7328 type
= &type
->data
.generic_class
->container_class
->byval_arg
;
7331 case MONO_TYPE_VOID
:
7335 g_error ("unknown type 0x%02x in mono_class_array_element_size", type
->type
);
7341 * mono_array_element_size:
7342 * @ac: pointer to a #MonoArrayClass
7344 * Returns: the size of single array element.
7347 mono_array_element_size (MonoClass
*ac
)
7349 g_assert (ac
->rank
);
7350 return ac
->sizes
.element_size
;
7354 mono_ldtoken (MonoImage
*image
, guint32 token
, MonoClass
**handle_class
,
7355 MonoGenericContext
*context
)
7357 if (image
->dynamic
) {
7358 MonoClass
*tmp_handle_class
;
7359 gpointer obj
= mono_lookup_dynamic_token_class (image
, token
, TRUE
, &tmp_handle_class
, context
);
7361 g_assert (tmp_handle_class
);
7363 *handle_class
= tmp_handle_class
;
7365 if (tmp_handle_class
== mono_defaults
.typehandle_class
)
7366 return &((MonoClass
*)obj
)->byval_arg
;
7371 switch (token
& 0xff000000) {
7372 case MONO_TOKEN_TYPE_DEF
:
7373 case MONO_TOKEN_TYPE_REF
:
7374 case MONO_TOKEN_TYPE_SPEC
: {
7377 *handle_class
= mono_defaults
.typehandle_class
;
7378 type
= mono_type_get_full (image
, token
, context
);
7381 mono_class_init (mono_class_from_mono_type (type
));
7382 /* We return a MonoType* as handle */
7385 case MONO_TOKEN_FIELD_DEF
: {
7387 guint32 type
= mono_metadata_typedef_from_field (image
, mono_metadata_token_index (token
));
7391 *handle_class
= mono_defaults
.fieldhandle_class
;
7392 class = mono_class_get_full (image
, MONO_TOKEN_TYPE_DEF
| type
, context
);
7395 mono_class_init (class);
7396 return mono_class_get_field (class, token
);
7398 case MONO_TOKEN_METHOD_DEF
:
7399 case MONO_TOKEN_METHOD_SPEC
: {
7401 meth
= mono_get_method_full (image
, token
, NULL
, context
);
7403 *handle_class
= mono_defaults
.methodhandle_class
;
7406 case MONO_TOKEN_MEMBER_REF
: {
7407 guint32 cols
[MONO_MEMBERREF_SIZE
];
7409 mono_metadata_decode_row (&image
->tables
[MONO_TABLE_MEMBERREF
], mono_metadata_token_index (token
) - 1, cols
, MONO_MEMBERREF_SIZE
);
7410 sig
= mono_metadata_blob_heap (image
, cols
[MONO_MEMBERREF_SIGNATURE
]);
7411 mono_metadata_decode_blob_size (sig
, &sig
);
7412 if (*sig
== 0x6) { /* it's a field */
7414 MonoClassField
*field
;
7415 field
= mono_field_from_token (image
, token
, &klass
, context
);
7417 *handle_class
= mono_defaults
.fieldhandle_class
;
7421 meth
= mono_get_method_full (image
, token
, NULL
, context
);
7423 *handle_class
= mono_defaults
.methodhandle_class
;
7428 g_warning ("Unknown token 0x%08x in ldtoken", token
);
7435 * This function might need to call runtime functions so it can't be part
7436 * of the metadata library.
7438 static MonoLookupDynamicToken lookup_dynamic
= NULL
;
7441 mono_install_lookup_dynamic_token (MonoLookupDynamicToken func
)
7443 lookup_dynamic
= func
;
7447 mono_lookup_dynamic_token (MonoImage
*image
, guint32 token
, MonoGenericContext
*context
)
7449 MonoClass
*handle_class
;
7451 return lookup_dynamic (image
, token
, TRUE
, &handle_class
, context
);
7455 mono_lookup_dynamic_token_class (MonoImage
*image
, guint32 token
, gboolean valid_token
, MonoClass
**handle_class
, MonoGenericContext
*context
)
7457 return lookup_dynamic (image
, token
, valid_token
, handle_class
, context
);
7460 static MonoGetCachedClassInfo get_cached_class_info
= NULL
;
7463 mono_install_get_cached_class_info (MonoGetCachedClassInfo func
)
7465 get_cached_class_info
= func
;
7469 mono_class_get_cached_class_info (MonoClass
*klass
, MonoCachedClassInfo
*res
)
7471 if (!get_cached_class_info
)
7474 return get_cached_class_info (klass
, res
);
7478 mono_install_get_class_from_name (MonoGetClassFromName func
)
7480 get_class_from_name
= func
;
7484 mono_class_get_image (MonoClass
*klass
)
7486 return klass
->image
;
7490 * mono_class_get_element_class:
7491 * @klass: the MonoClass to act on
7493 * Returns: the element class of an array or an enumeration.
7496 mono_class_get_element_class (MonoClass
*klass
)
7498 return klass
->element_class
;
7502 * mono_class_is_valuetype:
7503 * @klass: the MonoClass to act on
7505 * Returns: true if the MonoClass represents a ValueType.
7508 mono_class_is_valuetype (MonoClass
*klass
)
7510 return klass
->valuetype
;
7514 * mono_class_is_enum:
7515 * @klass: the MonoClass to act on
7517 * Returns: true if the MonoClass represents an enumeration.
7520 mono_class_is_enum (MonoClass
*klass
)
7522 return klass
->enumtype
;
7526 * mono_class_enum_basetype:
7527 * @klass: the MonoClass to act on
7529 * Returns: the underlying type representation for an enumeration.
7532 mono_class_enum_basetype (MonoClass
*klass
)
7534 if (klass
->element_class
== klass
)
7535 /* SRE or broken types */
7538 return &klass
->element_class
->byval_arg
;
7542 * mono_class_get_parent
7543 * @klass: the MonoClass to act on
7545 * Returns: the parent class for this class.
7548 mono_class_get_parent (MonoClass
*klass
)
7550 return klass
->parent
;
7554 * mono_class_get_nesting_type;
7555 * @klass: the MonoClass to act on
7557 * Returns: the container type where this type is nested or NULL if this type is not a nested type.
7560 mono_class_get_nesting_type (MonoClass
*klass
)
7562 return klass
->nested_in
;
7566 * mono_class_get_rank:
7567 * @klass: the MonoClass to act on
7569 * Returns: the rank for the array (the number of dimensions).
7572 mono_class_get_rank (MonoClass
*klass
)
7578 * mono_class_get_flags:
7579 * @klass: the MonoClass to act on
7581 * The type flags from the TypeDef table from the metadata.
7582 * see the TYPE_ATTRIBUTE_* definitions on tabledefs.h for the
7585 * Returns: the flags from the TypeDef table.
7588 mono_class_get_flags (MonoClass
*klass
)
7590 return klass
->flags
;
7594 * mono_class_get_name
7595 * @klass: the MonoClass to act on
7597 * Returns: the name of the class.
7600 mono_class_get_name (MonoClass
*klass
)
7606 * mono_class_get_namespace:
7607 * @klass: the MonoClass to act on
7609 * Returns: the namespace of the class.
7612 mono_class_get_namespace (MonoClass
*klass
)
7614 return klass
->name_space
;
7618 * mono_class_get_type:
7619 * @klass: the MonoClass to act on
7621 * This method returns the internal Type representation for the class.
7623 * Returns: the MonoType from the class.
7626 mono_class_get_type (MonoClass
*klass
)
7628 return &klass
->byval_arg
;
7632 * mono_class_get_type_token
7633 * @klass: the MonoClass to act on
7635 * This method returns type token for the class.
7637 * Returns: the type token for the class.
7640 mono_class_get_type_token (MonoClass
*klass
)
7642 return klass
->type_token
;
7646 * mono_class_get_byref_type:
7647 * @klass: the MonoClass to act on
7652 mono_class_get_byref_type (MonoClass
*klass
)
7654 return &klass
->this_arg
;
7658 * mono_class_num_fields:
7659 * @klass: the MonoClass to act on
7661 * Returns: the number of static and instance fields in the class.
7664 mono_class_num_fields (MonoClass
*klass
)
7666 return klass
->field
.count
;
7670 * mono_class_num_methods:
7671 * @klass: the MonoClass to act on
7673 * Returns: the number of methods in the class.
7676 mono_class_num_methods (MonoClass
*klass
)
7678 return klass
->method
.count
;
7682 * mono_class_num_properties
7683 * @klass: the MonoClass to act on
7685 * Returns: the number of properties in the class.
7688 mono_class_num_properties (MonoClass
*klass
)
7690 mono_class_setup_properties (klass
);
7692 return klass
->ext
->property
.count
;
7696 * mono_class_num_events:
7697 * @klass: the MonoClass to act on
7699 * Returns: the number of events in the class.
7702 mono_class_num_events (MonoClass
*klass
)
7704 mono_class_setup_events (klass
);
7706 return klass
->ext
->event
.count
;
7710 * mono_class_get_fields:
7711 * @klass: the MonoClass to act on
7713 * This routine is an iterator routine for retrieving the fields in a class.
7715 * You must pass a gpointer that points to zero and is treated as an opaque handle to
7716 * iterate over all of the elements. When no more values are
7717 * available, the return value is NULL.
7719 * Returns: a @MonoClassField* on each iteration, or NULL when no more fields are available.
7722 mono_class_get_fields (MonoClass
* klass
, gpointer
*iter
)
7724 MonoClassField
* field
;
7728 mono_class_setup_fields_locking (klass
);
7729 if (klass
->exception_type
)
7731 /* start from the first */
7732 if (klass
->field
.count
) {
7733 return *iter
= &klass
->fields
[0];
7741 if (field
< &klass
->fields
[klass
->field
.count
]) {
7742 return *iter
= field
;
7748 * mono_class_get_methods
7749 * @klass: the MonoClass to act on
7751 * This routine is an iterator routine for retrieving the fields in a class.
7753 * You must pass a gpointer that points to zero and is treated as an opaque handle to
7754 * iterate over all of the elements. When no more values are
7755 * available, the return value is NULL.
7757 * Returns: a MonoMethod on each iteration or NULL when no more methods are available.
7760 mono_class_get_methods (MonoClass
* klass
, gpointer
*iter
)
7762 MonoMethod
** method
;
7766 mono_class_init (klass
);
7768 mono_class_setup_methods (klass
);
7771 * We can't fail lookup of methods otherwise the runtime will burst in flames on all sort of places.
7772 * FIXME we should better report this error to the caller
7774 if (!klass
->methods
)
7776 /* start from the first */
7777 if (klass
->method
.count
) {
7778 *iter
= &klass
->methods
[0];
7779 return klass
->methods
[0];
7787 if (method
< &klass
->methods
[klass
->method
.count
]) {
7795 * mono_class_get_virtual_methods:
7797 * Iterate over the virtual methods of KLASS.
7799 * LOCKING: Assumes the loader lock is held (because of the klass->methods check).
7802 mono_class_get_virtual_methods (MonoClass
* klass
, gpointer
*iter
)
7804 MonoMethod
** method
;
7807 if (klass
->methods
|| !MONO_CLASS_HAS_STATIC_METADATA (klass
) || mono_debug_using_mono_debugger ()) {
7809 mono_class_setup_methods (klass
);
7811 * We can't fail lookup of methods otherwise the runtime will burst in flames on all sort of places.
7812 * FIXME we should better report this error to the caller
7814 if (!klass
->methods
)
7816 /* start from the first */
7817 method
= &klass
->methods
[0];
7822 while (method
< &klass
->methods
[klass
->method
.count
]) {
7823 if (((*method
)->flags
& METHOD_ATTRIBUTE_VIRTUAL
))
7827 if (method
< &klass
->methods
[klass
->method
.count
]) {
7834 /* Search directly in metadata to avoid calling setup_methods () */
7835 MonoMethod
*res
= NULL
;
7841 start_index
= GPOINTER_TO_UINT (*iter
);
7844 for (i
= start_index
; i
< klass
->method
.count
; ++i
) {
7847 /* class->method.first points into the methodptr table */
7848 flags
= mono_metadata_decode_table_row_col (klass
->image
, MONO_TABLE_METHOD
, klass
->method
.first
+ i
, MONO_METHOD_FLAGS
);
7850 if (flags
& METHOD_ATTRIBUTE_VIRTUAL
)
7854 if (i
< klass
->method
.count
) {
7855 res
= mono_get_method (klass
->image
, MONO_TOKEN_METHOD_DEF
| (klass
->method
.first
+ i
+ 1), klass
);
7856 /* Add 1 here so the if (*iter) check fails */
7857 *iter
= GUINT_TO_POINTER (i
+ 1);
7866 * mono_class_get_properties:
7867 * @klass: the MonoClass to act on
7869 * This routine is an iterator routine for retrieving the properties in a class.
7871 * You must pass a gpointer that points to zero and is treated as an opaque handle to
7872 * iterate over all of the elements. When no more values are
7873 * available, the return value is NULL.
7875 * Returns: a @MonoProperty* on each invocation, or NULL when no more are available.
7878 mono_class_get_properties (MonoClass
* klass
, gpointer
*iter
)
7880 MonoProperty
* property
;
7884 mono_class_init (klass
);
7886 mono_class_setup_properties (klass
);
7887 /* start from the first */
7888 if (klass
->ext
->property
.count
) {
7889 return *iter
= &klass
->ext
->properties
[0];
7897 if (property
< &klass
->ext
->properties
[klass
->ext
->property
.count
]) {
7898 return *iter
= property
;
7904 * mono_class_get_events:
7905 * @klass: the MonoClass to act on
7907 * This routine is an iterator routine for retrieving the properties in a class.
7909 * You must pass a gpointer that points to zero and is treated as an opaque handle to
7910 * iterate over all of the elements. When no more values are
7911 * available, the return value is NULL.
7913 * Returns: a @MonoEvent* on each invocation, or NULL when no more are available.
7916 mono_class_get_events (MonoClass
* klass
, gpointer
*iter
)
7922 mono_class_init (klass
);
7924 mono_class_setup_events (klass
);
7925 /* start from the first */
7926 if (klass
->ext
->event
.count
) {
7927 return *iter
= &klass
->ext
->events
[0];
7935 if (event
< &klass
->ext
->events
[klass
->ext
->event
.count
]) {
7936 return *iter
= event
;
7942 * mono_class_get_interfaces
7943 * @klass: the MonoClass to act on
7945 * This routine is an iterator routine for retrieving the interfaces implemented by this class.
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.
7951 * Returns: a @Monoclass* on each invocation, or NULL when no more are available.
7954 mono_class_get_interfaces (MonoClass
* klass
, gpointer
*iter
)
7962 mono_class_init (klass
);
7963 if (!klass
->interfaces_inited
) {
7964 mono_class_setup_interfaces (klass
, &error
);
7965 if (!mono_error_ok (&error
)) {
7966 mono_error_cleanup (&error
);
7970 /* start from the first */
7971 if (klass
->interface_count
) {
7972 *iter
= &klass
->interfaces
[0];
7973 return klass
->interfaces
[0];
7981 if (iface
< &klass
->interfaces
[klass
->interface_count
]) {
7989 * mono_class_get_nested_types
7990 * @klass: the MonoClass to act on
7992 * This routine is an iterator routine for retrieving the nested types of a class.
7993 * This works only if @klass is non-generic, or a generic type definition.
7995 * You must pass a gpointer that points to zero and is treated as an opaque handle to
7996 * iterate over all of the elements. When no more values are
7997 * available, the return value is NULL.
7999 * Returns: a @Monoclass* on each invocation, or NULL when no more are available.
8002 mono_class_get_nested_types (MonoClass
* klass
, gpointer
*iter
)
8010 mono_class_init (klass
);
8011 if (!klass
->nested_classes_inited
) {
8012 if (!klass
->type_token
)
8013 klass
->nested_classes_inited
= TRUE
;
8014 mono_loader_lock ();
8015 if (!klass
->nested_classes_inited
) {
8016 i
= mono_metadata_nesting_typedef (klass
->image
, klass
->type_token
, 1);
8019 guint32 cols
[MONO_NESTED_CLASS_SIZE
];
8020 mono_metadata_decode_row (&klass
->image
->tables
[MONO_TABLE_NESTEDCLASS
], i
- 1, cols
, MONO_NESTED_CLASS_SIZE
);
8021 nclass
= mono_class_create_from_typedef (klass
->image
, MONO_TOKEN_TYPE_DEF
| cols
[MONO_NESTED_CLASS_NESTED
]);
8024 mono_class_alloc_ext (klass
);
8025 klass
->ext
->nested_classes
= g_list_prepend_image (klass
->image
, klass
->ext
->nested_classes
, nclass
);
8027 i
= mono_metadata_nesting_typedef (klass
->image
, klass
->type_token
, i
+ 1);
8030 mono_memory_barrier ();
8031 klass
->nested_classes_inited
= TRUE
;
8032 mono_loader_unlock ();
8036 /* start from the first */
8037 if (klass
->ext
&& klass
->ext
->nested_classes
) {
8038 *iter
= klass
->ext
->nested_classes
;
8039 return klass
->ext
->nested_classes
->data
;
8041 /* no nested types */
8055 * mono_field_get_name:
8056 * @field: the MonoClassField to act on
8058 * Returns: the name of the field.
8061 mono_field_get_name (MonoClassField
*field
)
8067 * mono_field_get_type:
8068 * @field: the MonoClassField to act on
8070 * Returns: MonoType of the field.
8073 mono_field_get_type (MonoClassField
*field
)
8079 * mono_field_get_parent:
8080 * @field: the MonoClassField to act on
8082 * Returns: MonoClass where the field was defined.
8085 mono_field_get_parent (MonoClassField
*field
)
8087 return field
->parent
;
8091 * mono_field_get_flags;
8092 * @field: the MonoClassField to act on
8094 * The metadata flags for a field are encoded using the
8095 * FIELD_ATTRIBUTE_* constants. See the tabledefs.h file for details.
8097 * Returns: the flags for the field.
8100 mono_field_get_flags (MonoClassField
*field
)
8102 return field
->type
->attrs
;
8106 * mono_field_get_offset;
8107 * @field: the MonoClassField to act on
8109 * Returns: the field offset.
8112 mono_field_get_offset (MonoClassField
*field
)
8114 return field
->offset
;
8118 mono_field_get_rva (MonoClassField
*field
)
8122 MonoClass
*klass
= field
->parent
;
8124 g_assert (field
->type
->attrs
& FIELD_ATTRIBUTE_HAS_FIELD_RVA
);
8126 if (!klass
->ext
|| !klass
->ext
->field_def_values
) {
8127 mono_loader_lock ();
8128 mono_class_alloc_ext (klass
);
8129 if (!klass
->ext
->field_def_values
)
8130 klass
->ext
->field_def_values
= mono_class_alloc0 (klass
, sizeof (MonoFieldDefaultValue
) * klass
->field
.count
);
8131 mono_loader_unlock ();
8134 field_index
= mono_field_get_index (field
);
8136 if (!klass
->ext
->field_def_values
[field_index
].data
&& !klass
->image
->dynamic
) {
8137 mono_metadata_field_info (field
->parent
->image
, klass
->field
.first
+ field_index
, NULL
, &rva
, NULL
);
8139 g_warning ("field %s in %s should have RVA data, but hasn't", mono_field_get_name (field
), field
->parent
->name
);
8140 klass
->ext
->field_def_values
[field_index
].data
= mono_image_rva_map (field
->parent
->image
, rva
);
8143 return klass
->ext
->field_def_values
[field_index
].data
;
8147 * mono_field_get_data;
8148 * @field: the MonoClassField to act on
8150 * Returns: pointer to the metadata constant value or to the field
8151 * data if it has an RVA flag.
8154 mono_field_get_data (MonoClassField
*field
)
8156 if (field
->type
->attrs
& FIELD_ATTRIBUTE_HAS_DEFAULT
) {
8157 MonoTypeEnum def_type
;
8159 return mono_class_get_field_default_value (field
, &def_type
);
8160 } else if (field
->type
->attrs
& FIELD_ATTRIBUTE_HAS_FIELD_RVA
) {
8161 return mono_field_get_rva (field
);
8168 * mono_property_get_name:
8169 * @prop: the MonoProperty to act on
8171 * Returns: the name of the property
8174 mono_property_get_name (MonoProperty
*prop
)
8180 * mono_property_get_set_method
8181 * @prop: the MonoProperty to act on.
8183 * Returns: the setter method of the property (A MonoMethod)
8186 mono_property_get_set_method (MonoProperty
*prop
)
8192 * mono_property_get_get_method
8193 * @prop: the MonoProperty to act on.
8195 * Returns: the setter method of the property (A MonoMethod)
8198 mono_property_get_get_method (MonoProperty
*prop
)
8204 * mono_property_get_parent:
8205 * @prop: the MonoProperty to act on.
8207 * Returns: the MonoClass where the property was defined.
8210 mono_property_get_parent (MonoProperty
*prop
)
8212 return prop
->parent
;
8216 * mono_property_get_flags:
8217 * @prop: the MonoProperty to act on.
8219 * The metadata flags for a property are encoded using the
8220 * PROPERTY_ATTRIBUTE_* constants. See the tabledefs.h file for details.
8222 * Returns: the flags for the property.
8225 mono_property_get_flags (MonoProperty
*prop
)
8231 * mono_event_get_name:
8232 * @event: the MonoEvent to act on
8234 * Returns: the name of the event.
8237 mono_event_get_name (MonoEvent
*event
)
8243 * mono_event_get_add_method:
8244 * @event: The MonoEvent to act on.
8246 * Returns: the @add' method for the event (a MonoMethod).
8249 mono_event_get_add_method (MonoEvent
*event
)
8255 * mono_event_get_remove_method:
8256 * @event: The MonoEvent to act on.
8258 * Returns: the @remove method for the event (a MonoMethod).
8261 mono_event_get_remove_method (MonoEvent
*event
)
8263 return event
->remove
;
8267 * mono_event_get_raise_method:
8268 * @event: The MonoEvent to act on.
8270 * Returns: the @raise method for the event (a MonoMethod).
8273 mono_event_get_raise_method (MonoEvent
*event
)
8275 return event
->raise
;
8279 * mono_event_get_parent:
8280 * @event: the MonoEvent to act on.
8282 * Returns: the MonoClass where the event is defined.
8285 mono_event_get_parent (MonoEvent
*event
)
8287 return event
->parent
;
8291 * mono_event_get_flags
8292 * @event: the MonoEvent to act on.
8294 * The metadata flags for an event are encoded using the
8295 * EVENT_* constants. See the tabledefs.h file for details.
8297 * Returns: the flags for the event.
8300 mono_event_get_flags (MonoEvent
*event
)
8302 return event
->attrs
;
8306 * mono_class_get_method_from_name:
8307 * @klass: where to look for the method
8308 * @name_space: name of the method
8309 * @param_count: number of parameters. -1 for any number.
8311 * Obtains a MonoMethod with a given name and number of parameters.
8312 * It only works if there are no multiple signatures for any given method name.
8315 mono_class_get_method_from_name (MonoClass
*klass
, const char *name
, int param_count
)
8317 return mono_class_get_method_from_name_flags (klass
, name
, param_count
, 0);
8321 find_method_in_metadata (MonoClass
*klass
, const char *name
, int param_count
, int flags
)
8323 MonoMethod
*res
= NULL
;
8326 /* Search directly in the metadata to avoid calling setup_methods () */
8327 for (i
= 0; i
< klass
->method
.count
; ++i
) {
8328 guint32 cols
[MONO_METHOD_SIZE
];
8331 /* class->method.first points into the methodptr table */
8332 mono_metadata_decode_table_row (klass
->image
, MONO_TABLE_METHOD
, klass
->method
.first
+ i
, cols
, MONO_METHOD_SIZE
);
8334 if (!strcmp (mono_metadata_string_heap (klass
->image
, cols
[MONO_METHOD_NAME
]), name
)) {
8335 method
= mono_get_method (klass
->image
, MONO_TOKEN_METHOD_DEF
| (klass
->method
.first
+ i
+ 1), klass
);
8336 if ((param_count
== -1) || mono_method_signature (method
)->param_count
== param_count
) {
8347 * mono_class_get_method_from_name_flags:
8348 * @klass: where to look for the method
8349 * @name_space: name of the method
8350 * @param_count: number of parameters. -1 for any number.
8351 * @flags: flags which must be set in the method
8353 * Obtains a MonoMethod with a given name and number of parameters.
8354 * It only works if there are no multiple signatures for any given method name.
8357 mono_class_get_method_from_name_flags (MonoClass
*klass
, const char *name
, int param_count
, int flags
)
8359 MonoMethod
*res
= NULL
;
8362 mono_class_init (klass
);
8364 if (klass
->generic_class
&& !klass
->methods
) {
8365 res
= mono_class_get_method_from_name_flags (klass
->generic_class
->container_class
, name
, param_count
, flags
);
8367 res
= mono_class_inflate_generic_method_full (res
, klass
, mono_class_get_context (klass
));
8371 if (klass
->methods
|| !MONO_CLASS_HAS_STATIC_METADATA (klass
)) {
8372 mono_class_setup_methods (klass
);
8374 We can't fail lookup of methods otherwise the runtime will burst in flames on all sort of places.
8375 See mono/tests/array_load_exception.il
8376 FIXME we should better report this error to the caller
8378 if (!klass
->methods
)
8380 for (i
= 0; i
< klass
->method
.count
; ++i
) {
8381 MonoMethod
*method
= klass
->methods
[i
];
8383 if (method
->name
[0] == name
[0] &&
8384 !strcmp (name
, method
->name
) &&
8385 (param_count
== -1 || mono_method_signature (method
)->param_count
== param_count
) &&
8386 ((method
->flags
& flags
) == flags
)) {
8393 res
= find_method_in_metadata (klass
, name
, param_count
, flags
);
8400 * mono_class_set_failure:
8401 * @klass: class in which the failure was detected
8402 * @ex_type: the kind of exception/error to be thrown (later)
8403 * @ex_data: exception data (specific to each type of exception/error)
8405 * Keep a detected failure informations in the class for later processing.
8406 * Note that only the first failure is kept.
8408 * LOCKING: Acquires the loader lock.
8411 mono_class_set_failure (MonoClass
*klass
, guint32 ex_type
, void *ex_data
)
8413 if (klass
->exception_type
)
8416 mono_loader_lock ();
8417 klass
->exception_type
= ex_type
;
8419 mono_image_property_insert (klass
->image
, klass
, MONO_CLASS_PROP_EXCEPTION_DATA
, ex_data
);
8420 mono_loader_unlock ();
8426 * mono_class_get_exception_data:
8428 * Return the exception_data property of KLASS.
8430 * LOCKING: Acquires the loader lock.
8433 mono_class_get_exception_data (MonoClass
*klass
)
8435 return mono_image_property_lookup (klass
->image
, klass
, MONO_CLASS_PROP_EXCEPTION_DATA
);
8439 * mono_classes_init:
8441 * Initialize the resources used by this module.
8444 mono_classes_init (void)
8446 mono_counters_register ("Inflated methods size",
8447 MONO_COUNTER_GENERICS
| MONO_COUNTER_INT
, &inflated_methods_size
);
8448 mono_counters_register ("Inflated classes",
8449 MONO_COUNTER_GENERICS
| MONO_COUNTER_INT
, &inflated_classes
);
8450 mono_counters_register ("Inflated classes size",
8451 MONO_COUNTER_GENERICS
| MONO_COUNTER_INT
, &inflated_classes_size
);
8452 mono_counters_register ("MonoClass size",
8453 MONO_COUNTER_METADATA
| MONO_COUNTER_INT
, &classes_size
);
8454 mono_counters_register ("MonoClassExt size",
8455 MONO_COUNTER_METADATA
| MONO_COUNTER_INT
, &class_ext_size
);
8459 * mono_classes_cleanup:
8461 * Free the resources used by this module.
8464 mono_classes_cleanup (void)
8466 if (global_interface_bitset
)
8467 mono_bitset_free (global_interface_bitset
);
8471 * mono_class_get_exception_for_failure:
8472 * @klass: class in which the failure was detected
8474 * Return a constructed MonoException than the caller can then throw
8475 * using mono_raise_exception - or NULL if no failure is present (or
8476 * doesn't result in an exception).
8479 mono_class_get_exception_for_failure (MonoClass
*klass
)
8481 gpointer exception_data
= mono_class_get_exception_data (klass
);
8483 switch (klass
->exception_type
) {
8484 case MONO_EXCEPTION_SECURITY_INHERITANCEDEMAND
: {
8485 MonoDomain
*domain
= mono_domain_get ();
8486 MonoSecurityManager
* secman
= mono_security_manager_get_methods ();
8487 MonoMethod
*method
= exception_data
;
8488 guint32 error
= (method
) ? MONO_METADATA_INHERITANCEDEMAND_METHOD
: MONO_METADATA_INHERITANCEDEMAND_CLASS
;
8489 MonoObject
*exc
= NULL
;
8493 args
[1] = mono_assembly_get_object (domain
, mono_image_get_assembly (klass
->image
));
8494 args
[2] = mono_type_get_object (domain
, &klass
->byval_arg
);
8495 args
[3] = (method
) ? mono_method_get_object (domain
, method
, NULL
) : NULL
;
8497 mono_runtime_invoke (secman
->inheritsecurityexception
, NULL
, args
, &exc
);
8498 return (MonoException
*) exc
;
8500 case MONO_EXCEPTION_TYPE_LOAD
: {
8503 char *str
= mono_type_get_full_name (klass
);
8504 char *astr
= klass
->image
->assembly
? mono_stringify_assembly_name (&klass
->image
->assembly
->aname
): NULL
;
8505 name
= mono_string_new (mono_domain_get (), str
);
8507 ex
= mono_get_exception_type_load (name
, astr
);
8511 case MONO_EXCEPTION_MISSING_METHOD
: {
8512 char *class_name
= exception_data
;
8513 char *assembly_name
= class_name
+ strlen (class_name
) + 1;
8515 return mono_get_exception_missing_method (class_name
, assembly_name
);
8517 case MONO_EXCEPTION_MISSING_FIELD
: {
8518 char *class_name
= exception_data
;
8519 char *member_name
= class_name
+ strlen (class_name
) + 1;
8521 return mono_get_exception_missing_field (class_name
, member_name
);
8523 case MONO_EXCEPTION_FILE_NOT_FOUND
: {
8524 char *msg_format
= exception_data
;
8525 char *assembly_name
= msg_format
+ strlen (msg_format
) + 1;
8526 char *msg
= g_strdup_printf (msg_format
, assembly_name
);
8529 ex
= mono_get_exception_file_not_found2 (msg
, mono_string_new (mono_domain_get (), assembly_name
));
8535 case MONO_EXCEPTION_BAD_IMAGE
: {
8536 return mono_get_exception_bad_image_format (exception_data
);
8539 MonoLoaderError
*error
;
8542 error
= mono_loader_get_last_error ();
8544 ex
= mono_loader_error_prepare_exception (error
);
8548 /* TODO - handle other class related failures */
8555 is_nesting_type (MonoClass
*outer_klass
, MonoClass
*inner_klass
)
8557 outer_klass
= mono_class_get_generic_type_definition (outer_klass
);
8558 inner_klass
= mono_class_get_generic_type_definition (inner_klass
);
8560 if (outer_klass
== inner_klass
)
8562 inner_klass
= inner_klass
->nested_in
;
8563 } while (inner_klass
);
8568 mono_class_get_generic_type_definition (MonoClass
*klass
)
8570 return klass
->generic_class
? klass
->generic_class
->container_class
: klass
;
8574 * Check if @klass is a subtype of @parent ignoring generic instantiations.
8576 * Generic instantiations are ignored for all super types of @klass.
8578 * Visibility checks ignoring generic instantiations.
8581 mono_class_has_parent_and_ignore_generics (MonoClass
*klass
, MonoClass
*parent
)
8584 klass
= mono_class_get_generic_type_definition (klass
);
8585 parent
= mono_class_get_generic_type_definition (parent
);
8587 for (i
= 0; i
< klass
->idepth
; ++i
) {
8588 if (parent
== mono_class_get_generic_type_definition (klass
->supertypes
[i
]))
8594 * Subtype can only access parent members with family protection if the site object
8595 * is subclass of Subtype. For example:
8596 * class A { protected int x; }
8598 * void valid_access () {
8602 * void invalid_access () {
8609 is_valid_family_access (MonoClass
*access_klass
, MonoClass
*member_klass
, MonoClass
*context_klass
)
8611 if (!mono_class_has_parent_and_ignore_generics (access_klass
, member_klass
))
8614 if (context_klass
== NULL
)
8616 /*if access_klass is not member_klass context_klass must be type compat*/
8617 if (access_klass
!= member_klass
&& !mono_class_has_parent_and_ignore_generics (context_klass
, access_klass
))
8623 can_access_internals (MonoAssembly
*accessing
, MonoAssembly
* accessed
)
8626 if (accessing
== accessed
)
8628 if (!accessed
|| !accessing
)
8631 /* extra safety under CoreCLR - the runtime does not verify the strongname signatures
8632 * anywhere so untrusted friends are not safe to access platform's code internals */
8633 if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR
) {
8634 if (!mono_security_core_clr_can_access_internals (accessing
->image
, accessed
->image
))
8638 mono_assembly_load_friends (accessed
);
8639 for (tmp
= accessed
->friend_assembly_names
; tmp
; tmp
= tmp
->next
) {
8640 MonoAssemblyName
*friend = tmp
->data
;
8641 /* Be conservative with checks */
8644 if (strcmp (accessing
->aname
.name
, friend->name
))
8646 if (friend->public_key_token
[0]) {
8647 if (!accessing
->aname
.public_key_token
[0])
8649 if (!mono_public_tokens_are_equal (friend->public_key_token
, accessing
->aname
.public_key_token
))
8658 * If klass is a generic type or if it is derived from a generic type, return the
8659 * MonoClass of the generic definition
8660 * Returns NULL if not found
8663 get_generic_definition_class (MonoClass
*klass
)
8666 if (klass
->generic_class
&& klass
->generic_class
->container_class
)
8667 return klass
->generic_class
->container_class
;
8668 klass
= klass
->parent
;
8674 can_access_instantiation (MonoClass
*access_klass
, MonoGenericInst
*ginst
)
8677 for (i
= 0; i
< ginst
->type_argc
; ++i
) {
8678 MonoType
*type
= ginst
->type_argv
[i
];
8679 switch (type
->type
) {
8680 case MONO_TYPE_SZARRAY
:
8681 if (!can_access_type (access_klass
, type
->data
.klass
))
8684 case MONO_TYPE_ARRAY
:
8685 if (!can_access_type (access_klass
, type
->data
.array
->eklass
))
8689 if (!can_access_type (access_klass
, mono_class_from_mono_type (type
->data
.type
)))
8692 case MONO_TYPE_CLASS
:
8693 case MONO_TYPE_VALUETYPE
:
8694 case MONO_TYPE_GENERICINST
:
8695 if (!can_access_type (access_klass
, mono_class_from_mono_type (type
)))
8703 can_access_type (MonoClass
*access_klass
, MonoClass
*member_klass
)
8707 if (access_klass
->element_class
&& !access_klass
->enumtype
)
8708 access_klass
= access_klass
->element_class
;
8710 if (member_klass
->element_class
&& !member_klass
->enumtype
)
8711 member_klass
= member_klass
->element_class
;
8713 access_level
= member_klass
->flags
& TYPE_ATTRIBUTE_VISIBILITY_MASK
;
8715 if (member_klass
->byval_arg
.type
== MONO_TYPE_VAR
|| member_klass
->byval_arg
.type
== MONO_TYPE_MVAR
)
8718 if (member_klass
->generic_class
&& !can_access_instantiation (access_klass
, member_klass
->generic_class
->context
.class_inst
))
8721 if (is_nesting_type (access_klass
, member_klass
) || (access_klass
->nested_in
&& is_nesting_type (access_klass
->nested_in
, member_klass
)))
8724 if (member_klass
->nested_in
&& !can_access_type (access_klass
, member_klass
->nested_in
))
8727 /*Non nested type with nested visibility. We just fail it.*/
8728 if (access_level
>= TYPE_ATTRIBUTE_NESTED_PRIVATE
&& access_level
<= TYPE_ATTRIBUTE_NESTED_FAM_OR_ASSEM
&& member_klass
->nested_in
== NULL
)
8731 switch (access_level
) {
8732 case TYPE_ATTRIBUTE_NOT_PUBLIC
:
8733 return can_access_internals (access_klass
->image
->assembly
, member_klass
->image
->assembly
);
8735 case TYPE_ATTRIBUTE_PUBLIC
:
8738 case TYPE_ATTRIBUTE_NESTED_PUBLIC
:
8741 case TYPE_ATTRIBUTE_NESTED_PRIVATE
:
8742 return is_nesting_type (member_klass
, access_klass
);
8744 case TYPE_ATTRIBUTE_NESTED_FAMILY
:
8745 return mono_class_has_parent_and_ignore_generics (access_klass
, member_klass
->nested_in
);
8747 case TYPE_ATTRIBUTE_NESTED_ASSEMBLY
:
8748 return can_access_internals (access_klass
->image
->assembly
, member_klass
->image
->assembly
);
8750 case TYPE_ATTRIBUTE_NESTED_FAM_AND_ASSEM
:
8751 return can_access_internals (access_klass
->image
->assembly
, member_klass
->nested_in
->image
->assembly
) &&
8752 mono_class_has_parent_and_ignore_generics (access_klass
, member_klass
->nested_in
);
8754 case TYPE_ATTRIBUTE_NESTED_FAM_OR_ASSEM
:
8755 return can_access_internals (access_klass
->image
->assembly
, member_klass
->nested_in
->image
->assembly
) ||
8756 mono_class_has_parent_and_ignore_generics (access_klass
, member_klass
->nested_in
);
8761 /* FIXME: check visibility of type, too */
8763 can_access_member (MonoClass
*access_klass
, MonoClass
*member_klass
, MonoClass
* context_klass
, int access_level
)
8765 MonoClass
*member_generic_def
;
8766 if (((access_klass
->generic_class
&& access_klass
->generic_class
->container_class
) ||
8767 access_klass
->generic_container
) &&
8768 (member_generic_def
= get_generic_definition_class (member_klass
))) {
8769 MonoClass
*access_container
;
8771 if (access_klass
->generic_container
)
8772 access_container
= access_klass
;
8774 access_container
= access_klass
->generic_class
->container_class
;
8776 if (can_access_member (access_container
, member_generic_def
, context_klass
, access_level
))
8780 /* Partition I 8.5.3.2 */
8781 /* the access level values are the same for fields and methods */
8782 switch (access_level
) {
8783 case FIELD_ATTRIBUTE_COMPILER_CONTROLLED
:
8784 /* same compilation unit */
8785 return access_klass
->image
== member_klass
->image
;
8786 case FIELD_ATTRIBUTE_PRIVATE
:
8787 return access_klass
== member_klass
;
8788 case FIELD_ATTRIBUTE_FAM_AND_ASSEM
:
8789 if (is_valid_family_access (access_klass
, member_klass
, context_klass
) &&
8790 can_access_internals (access_klass
->image
->assembly
, member_klass
->image
->assembly
))
8793 case FIELD_ATTRIBUTE_ASSEMBLY
:
8794 return can_access_internals (access_klass
->image
->assembly
, member_klass
->image
->assembly
);
8795 case FIELD_ATTRIBUTE_FAMILY
:
8796 if (is_valid_family_access (access_klass
, member_klass
, context_klass
))
8799 case FIELD_ATTRIBUTE_FAM_OR_ASSEM
:
8800 if (is_valid_family_access (access_klass
, member_klass
, context_klass
))
8802 return can_access_internals (access_klass
->image
->assembly
, member_klass
->image
->assembly
);
8803 case FIELD_ATTRIBUTE_PUBLIC
:
8810 mono_method_can_access_field (MonoMethod
*method
, MonoClassField
*field
)
8812 /* FIXME: check all overlapping fields */
8813 int can
= can_access_member (method
->klass
, field
->parent
, NULL
, field
->type
->attrs
& FIELD_ATTRIBUTE_FIELD_ACCESS_MASK
);
8815 MonoClass
*nested
= method
->klass
->nested_in
;
8817 can
= can_access_member (nested
, field
->parent
, NULL
, field
->type
->attrs
& FIELD_ATTRIBUTE_FIELD_ACCESS_MASK
);
8820 nested
= nested
->nested_in
;
8827 mono_method_can_access_method (MonoMethod
*method
, MonoMethod
*called
)
8829 int can
= can_access_member (method
->klass
, called
->klass
, NULL
, called
->flags
& METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK
);
8831 MonoClass
*nested
= method
->klass
->nested_in
;
8833 can
= can_access_member (nested
, called
->klass
, NULL
, called
->flags
& METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK
);
8836 nested
= nested
->nested_in
;
8841 * with generics calls to explicit interface implementations can be expressed
8842 * directly: the method is private, but we must allow it. This may be opening
8843 * a hole or the generics code should handle this differently.
8844 * Maybe just ensure the interface type is public.
8846 if ((called
->flags
& METHOD_ATTRIBUTE_VIRTUAL
) && (called
->flags
& METHOD_ATTRIBUTE_FINAL
))
8852 * mono_method_can_access_method_full:
8853 * @method: The caller method
8854 * @called: The called method
8855 * @context_klass: The static type on stack of the owner @called object used
8857 * This function must be used with instance calls, as they have more strict family accessibility.
8858 * It can be used with static methods, but context_klass should be NULL.
8860 * Returns: TRUE if caller have proper visibility and acessibility to @called
8863 mono_method_can_access_method_full (MonoMethod
*method
, MonoMethod
*called
, MonoClass
*context_klass
)
8865 MonoClass
*access_class
= method
->klass
;
8866 MonoClass
*member_class
= called
->klass
;
8867 int can
= can_access_member (access_class
, member_class
, context_klass
, called
->flags
& METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK
);
8869 MonoClass
*nested
= access_class
->nested_in
;
8871 can
= can_access_member (nested
, member_class
, context_klass
, called
->flags
& METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK
);
8874 nested
= nested
->nested_in
;
8881 if (!can_access_type (access_class
, member_class
) && (!access_class
->nested_in
|| !can_access_type (access_class
->nested_in
, member_class
)))
8884 if (called
->is_inflated
) {
8885 MonoMethodInflated
* infl
= (MonoMethodInflated
*)called
;
8886 if (infl
->context
.method_inst
&& !can_access_instantiation (access_class
, infl
->context
.method_inst
))
8895 * mono_method_can_access_field_full:
8896 * @method: The caller method
8897 * @field: The accessed field
8898 * @context_klass: The static type on stack of the owner @field object used
8900 * This function must be used with instance fields, as they have more strict family accessibility.
8901 * It can be used with static fields, but context_klass should be NULL.
8903 * Returns: TRUE if caller have proper visibility and acessibility to @field
8906 mono_method_can_access_field_full (MonoMethod
*method
, MonoClassField
*field
, MonoClass
*context_klass
)
8908 MonoClass
*access_class
= method
->klass
;
8909 MonoClass
*member_class
= field
->parent
;
8910 /* FIXME: check all overlapping fields */
8911 int can
= can_access_member (access_class
, member_class
, context_klass
, field
->type
->attrs
& FIELD_ATTRIBUTE_FIELD_ACCESS_MASK
);
8913 MonoClass
*nested
= access_class
->nested_in
;
8915 can
= can_access_member (nested
, member_class
, context_klass
, field
->type
->attrs
& FIELD_ATTRIBUTE_FIELD_ACCESS_MASK
);
8918 nested
= nested
->nested_in
;
8925 if (!can_access_type (access_class
, member_class
) && (!access_class
->nested_in
|| !can_access_type (access_class
->nested_in
, member_class
)))
8931 * mono_type_is_valid_enum_basetype:
8932 * @type: The MonoType to check
8934 * Returns: TRUE if the type can be used as the basetype of an enum
8936 gboolean
mono_type_is_valid_enum_basetype (MonoType
* type
) {
8937 switch (type
->type
) {
8940 case MONO_TYPE_BOOLEAN
:
8943 case MONO_TYPE_CHAR
:
8956 * mono_class_is_valid_enum:
8957 * @klass: An enum class to be validated
8959 * This method verify the required properties an enum should have.
8961 * Returns: TRUE if the informed enum class is valid
8963 * FIXME: TypeBuilder enums are allowed to implement interfaces, but since they cannot have methods, only empty interfaces are possible
8964 * FIXME: enum types are not allowed to have a cctor, but mono_reflection_create_runtime_class sets has_cctor to 1 for all types
8965 * FIXME: TypeBuilder enums can have any kind of static fields, but the spec is very explicit about that (P II 14.3)
8967 gboolean
mono_class_is_valid_enum (MonoClass
*klass
) {
8968 MonoClassField
* field
;
8969 gpointer iter
= NULL
;
8970 gboolean found_base_field
= FALSE
;
8972 g_assert (klass
->enumtype
);
8973 /* we cannot test against mono_defaults.enum_class, or mcs won't be able to compile the System namespace*/
8974 if (!klass
->parent
|| strcmp (klass
->parent
->name
, "Enum") || strcmp (klass
->parent
->name_space
, "System") ) {
8978 if ((klass
->flags
& TYPE_ATTRIBUTE_LAYOUT_MASK
) != TYPE_ATTRIBUTE_AUTO_LAYOUT
)
8981 while ((field
= mono_class_get_fields (klass
, &iter
))) {
8982 if (!(field
->type
->attrs
& FIELD_ATTRIBUTE_STATIC
)) {
8983 if (found_base_field
)
8985 found_base_field
= TRUE
;
8986 if (!mono_type_is_valid_enum_basetype (field
->type
))
8991 if (!found_base_field
)
8994 if (klass
->method
.count
> 0)
9001 mono_generic_class_is_generic_type_definition (MonoGenericClass
*gklass
)
9003 return gklass
->context
.class_inst
== gklass
->container_class
->generic_container
->context
.class_inst
;
9007 * mono_class_setup_interface_id:
9009 * Initializes MonoClass::interface_id if required.
9011 * LOCKING: Acquires the loader lock.
9014 mono_class_setup_interface_id (MonoClass
*class)
9016 mono_loader_lock ();
9017 if (MONO_CLASS_IS_INTERFACE (class) && !class->interface_id
)
9018 class->interface_id
= mono_get_unique_iid (class);
9019 mono_loader_unlock ();
9023 * mono_class_alloc_ext:
9025 * Allocate klass->ext if not already done.
9026 * LOCKING: Assumes the loader lock is held.
9029 mono_class_alloc_ext (MonoClass
*klass
)
9032 klass
->ext
= mono_class_alloc0 (klass
, sizeof (MonoClassExt
));
9033 class_ext_size
+= sizeof (MonoClassExt
);
9038 * mono_class_setup_interfaces:
9040 * Initialize class->interfaces/interfaces_count.
9041 * LOCKING: Acquires the loader lock.
9042 * This function can fail the type.
9045 mono_class_setup_interfaces (MonoClass
*klass
, MonoError
*error
)
9049 mono_error_init (error
);
9051 if (klass
->interfaces_inited
)
9054 mono_loader_lock ();
9056 if (klass
->interfaces_inited
) {
9057 mono_loader_unlock ();
9061 if (klass
->rank
== 1 && klass
->byval_arg
.type
!= MONO_TYPE_ARRAY
&& mono_defaults
.generic_ilist_class
) {
9064 /* generic IList, ICollection, IEnumerable */
9065 klass
->interface_count
= 1;
9066 klass
->interfaces
= mono_image_alloc0 (klass
->image
, sizeof (MonoClass
*) * klass
->interface_count
);
9068 args
[0] = &klass
->element_class
->byval_arg
;
9069 klass
->interfaces
[0] = mono_class_bind_generic_parameters (
9070 mono_defaults
.generic_ilist_class
, 1, args
, FALSE
);
9071 } else if (klass
->generic_class
) {
9072 MonoClass
*gklass
= klass
->generic_class
->container_class
;
9074 klass
->interface_count
= gklass
->interface_count
;
9075 klass
->interfaces
= mono_class_new0 (klass
, MonoClass
*, klass
->interface_count
);
9076 for (i
= 0; i
< klass
->interface_count
; i
++) {
9077 klass
->interfaces
[i
] = mono_class_inflate_generic_class_checked (gklass
->interfaces
[i
], mono_generic_class_get_context (klass
->generic_class
), error
);
9078 if (!mono_error_ok (error
)) {
9079 mono_class_set_failure (klass
, MONO_EXCEPTION_TYPE_LOAD
, g_strdup ("Could not setup the interfaces"));
9080 g_free (klass
->interfaces
);
9081 klass
->interfaces
= NULL
;
9087 mono_memory_barrier ();
9089 klass
->interfaces_inited
= TRUE
;
9091 mono_loader_unlock ();