mono/metadata/class.c

   1 /*
   2  * class.c: Class management for the Mono runtime
   3  *
   4  * Author:
   5  *   Miguel de Icaza (miguel@ximian.com)
   6  *
   7  * (C) 2001-2006 Novell, Inc.
   8  *
   9  */
  10 #include <config.h>
  11 #include <glib.h>
  12 #include <stdio.h>
  13 #include <string.h>
  14 #include <stdlib.h>
  15 #include <signal.h>
  16 #if !PLATFORM_WIN32
  17 #include <mono/io-layer/atomic.h>
  18 #endif
  19 #include <mono/metadata/image.h>
  20 #include <mono/metadata/assembly.h>
  21 #include <mono/metadata/metadata.h>
  22 #include <mono/metadata/metadata-internals.h>
  23 #include <mono/metadata/profiler-private.h>
  24 #include <mono/metadata/tabledefs.h>
  25 #include <mono/metadata/tokentype.h>
  26 #include <mono/metadata/class-internals.h>
  27 #include <mono/metadata/object.h>
  28 #include <mono/metadata/appdomain.h>
  29 #include <mono/metadata/mono-endian.h>
  30 #include <mono/metadata/debug-helpers.h>
  31 #include <mono/metadata/reflection.h>
  32 #include <mono/metadata/exception.h>
  33 #include <mono/metadata/security-manager.h>
  34 #include <mono/metadata/security-core-clr.h>
  35 #include <mono/metadata/attrdefs.h>
  36 #include <mono/metadata/gc-internal.h>
  37 #include <mono/metadata/verify-internals.h>
  38 #include <mono/metadata/mono-debug.h>
  39 #include <mono/utils/mono-counters.h>
  40
  41 MonoStats mono_stats;
  42
  43 gboolean mono_print_vtable = FALSE;
  44
  45 /*
  46  * Controls whenever mono_class_init () constructs a generic vtable. This is TRUE by
  47  * default to avoid breaking embedding apps, but set to FALSE by the runtime executable
  48  * startup code.
  49  */
  50 gboolean mono_setup_vtable_in_class_init = TRUE;
  51
  52 /* Function supplied by the runtime to find classes by name using information from the AOT file */
  53 static MonoGetClassFromName get_class_from_name = NULL;
  54
  55 static MonoClass * mono_class_create_from_typedef (MonoImage *image, guint32 type_token);
  56 static gboolean mono_class_get_cached_class_info (MonoClass *klass, MonoCachedClassInfo *res);
  57 static gboolean can_access_type (MonoClass *access_klass, MonoClass *member_klass);
  58 static MonoMethod* find_method_in_metadata (MonoClass *klass, const char *name, int param_count, int flags);
  59 static int generic_array_methods (MonoClass *class);
  60 static void setup_generic_array_ifaces (MonoClass *class, MonoClass *iface, MonoMethod **methods, int pos);
  61
  62 static MonoMethod* mono_class_get_virtual_methods (MonoClass* klass, gpointer *iter);
  63
  64 void (*mono_debugger_class_init_func) (MonoClass *klass) = NULL;
  65 void (*mono_debugger_class_loaded_methods_func) (MonoClass *klass) = NULL;
  66
  67 /*
  68  * mono_class_from_typeref:
  69  * @image: a MonoImage
  70  * @type_token: a TypeRef token
  71  *
  72  * Creates the MonoClass* structure representing the type defined by
  73  * the typeref token valid inside @image.
  74  * Returns: the MonoClass* representing the typeref token, NULL ifcould
  75  * not be loaded.
  76  */
  77 MonoClass *
  78 mono_class_from_typeref (MonoImage *image, guint32 type_token)
  79 {
  80         guint32 cols [MONO_TYPEREF_SIZE];
  81         MonoTableInfo  *t = &image->tables [MONO_TABLE_TYPEREF];
  82         guint32 idx;
  83         const char *name, *nspace;
  84         MonoClass *res;
  85         MonoImage *module;
  86
  87         mono_metadata_decode_row (t, (type_token&0xffffff)-1, cols, MONO_TYPEREF_SIZE);
  88
  89         name = mono_metadata_string_heap (image, cols [MONO_TYPEREF_NAME]);
  90         nspace = mono_metadata_string_heap (image, cols [MONO_TYPEREF_NAMESPACE]);
  91
  92         idx = cols [MONO_TYPEREF_SCOPE] >> MONO_RESOLTION_SCOPE_BITS;
  93         switch (cols [MONO_TYPEREF_SCOPE] & MONO_RESOLTION_SCOPE_MASK) {
  94         case MONO_RESOLTION_SCOPE_MODULE:
  95                 if (!idx)
  96                         g_error ("null ResolutionScope not yet handled");
  97                 /* a typedef in disguise */
  98                 return mono_class_from_name (image, nspace, name);
  99         case MONO_RESOLTION_SCOPE_MODULEREF:
 100                 module = mono_image_load_module (image, idx);
 101                 if (module)
 102                         return mono_class_from_name (module, nspace, name);
 103                 else {
 104                         char *msg = g_strdup_printf ("%s%s%s", nspace, nspace [0] ? "." : "", name);
 105                         char *human_name;
 106
 107                         human_name = mono_stringify_assembly_name (&image->assembly->aname);
 108                         mono_loader_set_error_type_load (msg, human_name);
 109                         g_free (msg);
 110                         g_free (human_name);
 111
 112                         return NULL;
 113                 }
 114         case MONO_RESOLTION_SCOPE_TYPEREF: {
 115                 MonoClass *enclosing = mono_class_from_typeref (image, MONO_TOKEN_TYPE_REF | idx);
 116                 GList *tmp;
 117
 118                 if (enclosing->nested_classes_inited) {
 119                         /* Micro-optimization: don't scan the metadata tables if enclosing is already inited */
 120                         for (tmp = enclosing->nested_classes; tmp; tmp = tmp->next) {
 121                                 res = tmp->data;
 122                                 if (strcmp (res->name, name) == 0)
 123                                         return res;
 124                         }
 125                 } else {
 126                         /* Don't call mono_class_init as we might've been called by it recursively */
 127                         int i = mono_metadata_nesting_typedef (enclosing->image, enclosing->type_token, 1);
 128                         while (i) {
 129                                 guint32 class_nested = mono_metadata_decode_row_col (&enclosing->image->tables [MONO_TABLE_NESTEDCLASS], i - 1, MONO_NESTED_CLASS_NESTED);
 130                                 guint32 string_offset = mono_metadata_decode_row_col (&enclosing->image->tables [MONO_TABLE_TYPEDEF], class_nested - 1, MONO_TYPEDEF_NAME);
 131                                 const char *nname = mono_metadata_string_heap (enclosing->image, string_offset);
 132
 133                                 if (strcmp (nname, name) == 0)
 134                                         return mono_class_create_from_typedef (enclosing->image, MONO_TOKEN_TYPE_DEF | class_nested);
 135
 136                                 i = mono_metadata_nesting_typedef (enclosing->image, enclosing->type_token, i + 1);
 137                         }
 138                 }
 139                 g_warning ("TypeRef ResolutionScope not yet handled (%d) for %s.%s in image %s", idx, nspace, name, image->name);
 140                 return NULL;
 141         }
 142         case MONO_RESOLTION_SCOPE_ASSEMBLYREF:
 143                 break;
 144         }
 145
 146         if (!image->references || !image->references [idx - 1])
 147                 mono_assembly_load_reference (image, idx - 1);
 148         g_assert (image->references [idx - 1]);
 149
 150         /* If the assembly did not load, register this as a type load exception */
 151         if (image->references [idx - 1] == REFERENCE_MISSING){
 152                 MonoAssemblyName aname;
 153                 char *human_name;
 154
 155                 mono_assembly_get_assemblyref (image, idx - 1, &aname);
 156                 human_name = mono_stringify_assembly_name (&aname);
 157                 mono_loader_set_error_assembly_load (human_name, image->assembly->ref_only);
 158                 g_free (human_name);
 159
 160                 return NULL;
 161         }
 162
 163         return mono_class_from_name (image->references [idx - 1]->image, nspace, name);
 164 }
 165
 166
 167 static void *
 168 mono_mempool_dup (MonoMemPool *mp, void *data, guint size)
 169 {
 170         void *res = mono_mempool_alloc (mp, size);
 171         memcpy (res, data, size);
 172         return res;
 173 }
 174
 175 /* Copy everything mono_metadata_free_array free. */
 176 MonoArrayType *
 177 mono_dup_array_type (MonoMemPool *mp, MonoArrayType *a)
 178 {
 179         if (mp) {
 180                 mono_loader_lock ();
 181                 a = mono_mempool_dup (mp, a, sizeof (MonoArrayType));
 182                 if (a->sizes)
 183                         a->sizes = mono_mempool_dup (mp, a->sizes, a->numsizes * sizeof (int));
 184                 if (a->lobounds)
 185                         a->lobounds = mono_mempool_dup (mp, a->lobounds, a->numlobounds * sizeof (int));
 186                 mono_loader_unlock ();
 187         } else {
 188                 a = g_memdup (a, sizeof (MonoArrayType));
 189                 if (a->sizes)
 190                         a->sizes = g_memdup (a->sizes, a->numsizes * sizeof (int));
 191                 if (a->lobounds)
 192                         a->lobounds = g_memdup (a->lobounds, a->numlobounds * sizeof (int));
 193         }
 194         return a;
 195 }
 196
 197 /* Copy everything mono_metadata_free_method_signature free. */
 198 MonoMethodSignature*
 199 mono_metadata_signature_deep_dup (MonoMemPool *mp, MonoMethodSignature *sig)
 200 {
 201         int i;
 202
 203         sig = mono_metadata_signature_dup_full (mp, sig);
 204
 205         sig->ret = mono_metadata_type_dup (mp, sig->ret);
 206         for (i = 0; i < sig->param_count; ++i)
 207                 sig->params [i] = mono_metadata_type_dup (mp, sig->params [i]);
 208
 209         return sig;
 210 }
 211
 212 static void
 213 _mono_type_get_assembly_name (MonoClass *klass, GString *str)
 214 {
 215         MonoAssembly *ta = klass->image->assembly;
 216
 217         g_string_append_printf (
 218                 str, ", %s, Version=%d.%d.%d.%d, Culture=%s, PublicKeyToken=%s%s",
 219                 ta->aname.name,
 220                 ta->aname.major, ta->aname.minor, ta->aname.build, ta->aname.revision,
 221                 ta->aname.culture && *ta->aname.culture? ta->aname.culture: "neutral",
 222                 ta->aname.public_key_token [0] ? (char *)ta->aname.public_key_token : "null",
 223                 (ta->aname.flags & ASSEMBLYREF_RETARGETABLE_FLAG) ? ", Retargetable=Yes" : "");
 224 }
 225
 226 static inline void
 227 mono_type_name_check_byref (MonoType *type, GString *str)
 228 {
 229         if (type->byref)
 230                 g_string_append_c (str, '&');
 231 }
 232
 233 static void
 234 mono_type_get_name_recurse (MonoType *type, GString *str, gboolean is_recursed,
 235                             MonoTypeNameFormat format)
 236 {
 237         MonoClass *klass;
 238
 239         switch (type->type) {
 240         case MONO_TYPE_ARRAY: {
 241                 int i, rank = type->data.array->rank;
 242                 MonoTypeNameFormat nested_format;
 243
 244                 nested_format = format == MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED ?
 245                         MONO_TYPE_NAME_FORMAT_FULL_NAME : format;
 246
 247                 mono_type_get_name_recurse (
 248                         &type->data.array->eklass->byval_arg, str, FALSE, nested_format);
 249                 g_string_append_c (str, '[');
 250                 if (rank == 1)
 251                         g_string_append_c (str, '*');
 252                 for (i = 1; i < rank; i++)
 253                         g_string_append_c (str, ',');
 254                 g_string_append_c (str, ']');
 255
 256                 mono_type_name_check_byref (type, str);
 257
 258                 if (format == MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED)
 259                         _mono_type_get_assembly_name (type->data.array->eklass, str);
 260                 break;
 261         }
 262         case MONO_TYPE_SZARRAY: {
 263                 MonoTypeNameFormat nested_format;
 264
 265                 nested_format = format == MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED ?
 266                         MONO_TYPE_NAME_FORMAT_FULL_NAME : format;
 267
 268                 mono_type_get_name_recurse (
 269                         &type->data.klass->byval_arg, str, FALSE, nested_format);
 270                 g_string_append (str, "[]");
 271
 272                 mono_type_name_check_byref (type, str);
 273
 274                 if (format == MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED)
 275                         _mono_type_get_assembly_name (type->data.klass, str);
 276                 break;
 277         }
 278         case MONO_TYPE_PTR: {
 279                 MonoTypeNameFormat nested_format;
 280
 281                 nested_format = format == MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED ?
 282                         MONO_TYPE_NAME_FORMAT_FULL_NAME : format;
 283
 284                 mono_type_get_name_recurse (
 285                         type->data.type, str, FALSE, nested_format);
 286                 g_string_append_c (str, '*');
 287
 288                 mono_type_name_check_byref (type, str);
 289
 290                 if (format == MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED)
 291                         _mono_type_get_assembly_name (mono_class_from_mono_type (type->data.type), str);
 292                 break;
 293         }
 294         case MONO_TYPE_VAR:
 295         case MONO_TYPE_MVAR:
 296                 g_assert (type->data.generic_param->name);
 297                 g_string_append (str, type->data.generic_param->name);
 298
 299                 mono_type_name_check_byref (type, str);
 300
 301                 break;
 302         default:
 303                 klass = mono_class_from_mono_type (type);
 304                 if (klass->nested_in) {
 305                         mono_type_get_name_recurse (
 306                                 &klass->nested_in->byval_arg, str, TRUE, format);
 307                         if (format == MONO_TYPE_NAME_FORMAT_IL)
 308                                 g_string_append_c (str, '.');
 309                         else
 310                                 g_string_append_c (str, '+');
 311                 } else if (*klass->name_space) {
 312                         g_string_append (str, klass->name_space);
 313                         g_string_append_c (str, '.');
 314                 }
 315                 if (format == MONO_TYPE_NAME_FORMAT_IL) {
 316                         char *s = strchr (klass->name, '`');
 317                         int len = s ? s - klass->name : strlen (klass->name);
 318
 319                         g_string_append_len (str, klass->name, len);
 320                 } else
 321                         g_string_append (str, klass->name);
 322                 if (is_recursed)
 323                         break;
 324                 if (klass->generic_class) {
 325                         MonoGenericClass *gclass = klass->generic_class;
 326                         MonoGenericInst *inst = gclass->context.class_inst;
 327                         MonoTypeNameFormat nested_format;
 328                         int i;
 329
 330                         nested_format = format == MONO_TYPE_NAME_FORMAT_FULL_NAME ?
 331                                 MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED : format;
 332
 333                         if (format == MONO_TYPE_NAME_FORMAT_IL)
 334                                 g_string_append_c (str, '<');
 335                         else
 336                                 g_string_append_c (str, '[');
 337                         for (i = 0; i < inst->type_argc; i++) {
 338                                 MonoType *t = inst->type_argv [i];
 339
 340                                 if (i)
 341                                         g_string_append_c (str, ',');
 342                                 if ((nested_format == MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED) &&
 343                                     (t->type != MONO_TYPE_VAR) && (type->type != MONO_TYPE_MVAR))
 344                                         g_string_append_c (str, '[');
 345                                 mono_type_get_name_recurse (inst->type_argv [i], str, FALSE, nested_format);
 346                                 if ((nested_format == MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED) &&
 347                                     (t->type != MONO_TYPE_VAR) && (type->type != MONO_TYPE_MVAR))
 348                                         g_string_append_c (str, ']');
 349                         }
 350                         if (format == MONO_TYPE_NAME_FORMAT_IL)
 351                                 g_string_append_c (str, '>');
 352                         else
 353                                 g_string_append_c (str, ']');
 354                 } else if (klass->generic_container &&
 355                            (format != MONO_TYPE_NAME_FORMAT_FULL_NAME) &&
 356                            (format != MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED)) {
 357                         int i;
 358
 359                         if (format == MONO_TYPE_NAME_FORMAT_IL)
 360                                 g_string_append_c (str, '<');
 361                         else
 362                                 g_string_append_c (str, '[');
 363                         for (i = 0; i < klass->generic_container->type_argc; i++) {
 364                                 if (i)
 365                                         g_string_append_c (str, ',');
 366                                 g_string_append (str, klass->generic_container->type_params [i].name);
 367                         }
 368                         if (format == MONO_TYPE_NAME_FORMAT_IL)
 369                                 g_string_append_c (str, '>');
 370                         else
 371                                 g_string_append_c (str, ']');
 372                 }
 373
 374                 mono_type_name_check_byref (type, str);
 375
 376                 if ((format == MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED) &&
 377                     (type->type != MONO_TYPE_VAR) && (type->type != MONO_TYPE_MVAR))
 378                         _mono_type_get_assembly_name (klass, str);
 379                 break;
 380         }
 381 }
 382
 383 /**
 384  * mono_type_get_name:
 385  * @type: a type
 386  * @format: the format for the return string.
 387  *
 388  *
 389  * Returns: the string representation in a number of formats:
 390  *
 391  * if format is MONO_TYPE_NAME_FORMAT_REFLECTION, the return string is
 392  * returned in the formatrequired by System.Reflection, this is the
 393  * inverse of mono_reflection_parse_type ().
 394  *
 395  * if format is MONO_TYPE_NAME_FORMAT_IL, it returns a syntax that can
 396  * be used by the IL assembler.
 397  *
 398  * if format is MONO_TYPE_NAME_FORMAT_FULL_NAME
 399  *
 400  * if format is MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED
 401  */
 402 char*
 403 mono_type_get_name_full (MonoType *type, MonoTypeNameFormat format)
 404 {
 405         GString* result;
 406
 407         result = g_string_new ("");
 408
 409         mono_type_get_name_recurse (type, result, FALSE, format);
 410
 411         return g_string_free (result, FALSE);
 412 }
 413
 414 /**
 415  * mono_type_get_full_name:
 416  * @class: a class
 417  *
 418  * Returns: the string representation for type as required by System.Reflection.
 419  * The inverse of mono_reflection_parse_type ().
 420  */
 421 char *
 422 mono_type_get_full_name (MonoClass *class)
 423 {
 424         return mono_type_get_name_full (mono_class_get_type (class), MONO_TYPE_NAME_FORMAT_REFLECTION);
 425 }
 426
 427 /**
 428  * mono_type_get_name:
 429  * @type: a type
 430  *
 431  * Returns: the string representation for type as it would be represented in IL code.
 432  */
 433 char*
 434 mono_type_get_name (MonoType *type)
 435 {
 436         return mono_type_get_name_full (type, MONO_TYPE_NAME_FORMAT_IL);
 437 }
 438
 439 /*
 440  * mono_type_get_underlying_type:
 441  * @type: a type
 442  *
 443  * Returns: the MonoType for the underlying integer type if @type
 444  * is an enum and byref is false, otherwise the type itself.
 445  */
 446 MonoType*
 447 mono_type_get_underlying_type (MonoType *type)
 448 {
 449         if (type->type == MONO_TYPE_VALUETYPE && type->data.klass->enumtype && !type->byref)
 450                 return type->data.klass->enum_basetype;
 451         if (type->type == MONO_TYPE_GENERICINST && type->data.generic_class->container_class->enumtype && !type->byref)
 452                 return type->data.generic_class->container_class->enum_basetype;
 453         return type;
 454 }
 455
 456 /*
 457  * mono_class_is_open_constructed_type:
 458  * @type: a type
 459  *
 460  * Returns TRUE if type represents a generics open constructed type
 461  * (not all the type parameters required for the instantiation have
 462  * been provided).
 463  */
 464 gboolean
 465 mono_class_is_open_constructed_type (MonoType *t)
 466 {
 467         switch (t->type) {
 468         case MONO_TYPE_VAR:
 469         case MONO_TYPE_MVAR:
 470                 return TRUE;
 471         case MONO_TYPE_SZARRAY:
 472                 return mono_class_is_open_constructed_type (&t->data.klass->byval_arg);
 473         case MONO_TYPE_ARRAY:
 474                 return mono_class_is_open_constructed_type (&t->data.array->eklass->byval_arg);
 475         case MONO_TYPE_PTR:
 476                 return mono_class_is_open_constructed_type (t->data.type);
 477         case MONO_TYPE_GENERICINST:
 478                 return t->data.generic_class->context.class_inst->is_open;
 479         default:
 480                 return FALSE;
 481         }
 482 }
 483
 484 static MonoType*
 485 inflate_generic_type (MonoMemPool *mempool, MonoType *type, MonoGenericContext *context)
 486 {
 487         switch (type->type) {
 488         case MONO_TYPE_MVAR: {
 489                 MonoType *nt;
 490                 int num = type->data.generic_param->num;
 491                 MonoGenericInst *inst = context->method_inst;
 492                 if (!inst || !inst->type_argv)
 493                         return NULL;
 494                 if (num >= inst->type_argc)
 495                         g_error ("MVAR %d (%s) cannot be expanded in this context with %d instantiations", num, type->data.generic_param->name, inst->type_argc);
 496
 497                 /*
 498                  * Note that the VAR/MVAR cases are different from the rest.  The other cases duplicate @type,
 499                  * while the VAR/MVAR duplicates a type from the context.  So, we need to ensure that the
 500                  * ->byref and ->attrs from @type are propagated to the returned type.
 501                  */
 502                 nt = mono_metadata_type_dup (mempool, inst->type_argv [num]);
 503                 nt->byref = type->byref;
 504                 nt->attrs = type->attrs;
 505                 return nt;
 506         }
 507         case MONO_TYPE_VAR: {
 508                 MonoType *nt;
 509                 int num = type->data.generic_param->num;
 510                 MonoGenericInst *inst = context->class_inst;
 511                 if (!inst)
 512                         return NULL;
 513                 if (num >= inst->type_argc)
 514                         g_error ("VAR %d (%s) cannot be expanded in this context with %d instantiations", num, type->data.generic_param->name, inst->type_argc);
 515                 nt = mono_metadata_type_dup (mempool, inst->type_argv [num]);
 516                 nt->byref = type->byref;
 517                 nt->attrs = type->attrs;
 518                 return nt;
 519         }
 520         case MONO_TYPE_SZARRAY: {
 521                 MonoClass *eclass = type->data.klass;
 522                 MonoType *nt, *inflated = inflate_generic_type (NULL, &eclass->byval_arg, context);
 523                 if (!inflated)
 524                         return NULL;
 525                 nt = mono_metadata_type_dup (mempool, type);
 526                 nt->data.klass = mono_class_from_mono_type (inflated);
 527                 mono_metadata_free_type (inflated);
 528                 return nt;
 529         }
 530         case MONO_TYPE_ARRAY: {
 531                 MonoClass *eclass = type->data.array->eklass;
 532                 MonoType *nt, *inflated = inflate_generic_type (NULL, &eclass->byval_arg, context);
 533                 if (!inflated)
 534                         return NULL;
 535                 nt = mono_metadata_type_dup (mempool, type);
 536                 nt->data.array = g_memdup (nt->data.array, sizeof (MonoArrayType));
 537                 nt->data.array->eklass = mono_class_from_mono_type (inflated);
 538                 mono_metadata_free_type (inflated);
 539                 return nt;
 540         }
 541         case MONO_TYPE_GENERICINST: {
 542                 MonoGenericClass *gclass = type->data.generic_class;
 543                 MonoGenericInst *inst;
 544                 MonoType *nt;
 545                 if (!gclass->context.class_inst->is_open)
 546                         return NULL;
 547
 548                 inst = mono_metadata_inflate_generic_inst (gclass->context.class_inst, context);
 549                 if (inst != gclass->context.class_inst)
 550                         gclass = mono_metadata_lookup_generic_class (gclass->container_class, inst, gclass->is_dynamic);
 551
 552                 if (gclass == type->data.generic_class)
 553                         return NULL;
 554
 555                 nt = mono_metadata_type_dup (mempool, type);
 556                 nt->data.generic_class = gclass;
 557                 return nt;
 558         }
 559         case MONO_TYPE_CLASS:
 560         case MONO_TYPE_VALUETYPE: {
 561                 MonoClass *klass = type->data.klass;
 562                 MonoGenericContainer *container = klass->generic_container;
 563                 MonoGenericInst *inst;
 564                 MonoGenericClass *gclass = NULL;
 565                 MonoType *nt;
 566
 567                 if (!container)
 568                         return NULL;
 569
 570                 /* We can't use context->class_inst directly, since it can have more elements */
 571                 inst = mono_metadata_inflate_generic_inst (container->context.class_inst, context);
 572                 if (inst == container->context.class_inst)
 573                         return NULL;
 574
 575                 gclass = mono_metadata_lookup_generic_class (klass, inst, klass->image->dynamic);
 576
 577                 nt = mono_metadata_type_dup (mempool, type);
 578                 nt->type = MONO_TYPE_GENERICINST;
 579                 nt->data.generic_class = gclass;
 580                 return nt;
 581         }
 582         default:
 583                 return NULL;
 584         }
 585         return NULL;
 586 }
 587
 588 MonoGenericContext *
 589 mono_generic_class_get_context (MonoGenericClass *gclass)
 590 {
 591         return &gclass->context;
 592 }
 593
 594 MonoGenericContext *
 595 mono_class_get_context (MonoClass *class)
 596 {
 597        return class->generic_class ? mono_generic_class_get_context (class->generic_class) : NULL;
 598 }
 599
 600 /*
 601  * mono_class_inflate_generic_type_with_mempool:
 602  * @mempool: a mempool
 603  * @type: a type
 604  * @context: a generics context
 605  *
 606  * The same as mono_class_inflate_generic_type, but allocates the MonoType
 607  * from mempool if it is non-NULL.  If it is NULL, the MonoType is
 608  * allocated on the heap and is owned by the caller.
 609  * The returned type can potentially be the same as TYPE, so it should not be
 610  * modified by the caller, and it should be freed using mono_metadata_free_type ().
 611  */
 612 MonoType*
 613 mono_class_inflate_generic_type_with_mempool (MonoMemPool *mempool, MonoType *type, MonoGenericContext *context)
 614 {
 615         MonoType *inflated = NULL;
 616
 617         if (context)
 618                 inflated = inflate_generic_type (mempool, type, context);
 619
 620         if (!inflated) {
 621                 MonoType *shared = mono_metadata_get_shared_type (type);
 622
 623                 if (shared) {
 624                         return shared;
 625                 } else {
 626                         return mono_metadata_type_dup (mempool, type);
 627                 }
 628         }
 629
 630         mono_stats.inflated_type_count++;
 631         return inflated;
 632 }
 633
 634 /*
 635  * mono_class_inflate_generic_type:
 636  * @type: a type
 637  * @context: a generics context
 638  *
 639  * If @type is a generic type and @context is not NULL, instantiate it using the
 640  * generics context @context.
 641  *
 642  * Returns: the instantiated type or a copy of @type. The returned MonoType is allocated
 643  * on the heap and is owned by the caller.
 644  */
 645 MonoType*
 646 mono_class_inflate_generic_type (MonoType *type, MonoGenericContext *context)
 647 {
 648         return mono_class_inflate_generic_type_with_mempool (NULL, type, context);
 649 }
 650
 651 /*
 652  * mono_class_inflate_generic_type_with_mempool_no_copy:
 653  *
 654  *   Same as inflate_generic_type_with_mempool, but return TYPE if no inflation
 655  * was done.
 656  */
 657 static MonoType*
 658 mono_class_inflate_generic_type_with_mempool_no_copy (MonoMemPool *mempool, MonoType *type, MonoGenericContext *context)
 659 {
 660         MonoType *inflated = NULL;
 661
 662         if (context)
 663                 inflated = inflate_generic_type (mempool, type, context);
 664
 665         if (!inflated)
 666                 return type;
 667
 668         mono_stats.inflated_type_count++;
 669         return inflated;
 670 }
 671
 672 static MonoGenericContext
 673 inflate_generic_context (MonoGenericContext *context, MonoGenericContext *inflate_with)
 674 {
 675         MonoGenericInst *class_inst = NULL;
 676         MonoGenericInst *method_inst = NULL;
 677         MonoGenericContext res;
 678
 679         if (context->class_inst)
 680                 class_inst = mono_metadata_inflate_generic_inst (context->class_inst, inflate_with);
 681
 682         if (context->method_inst)
 683                 method_inst = mono_metadata_inflate_generic_inst (context->method_inst, inflate_with);
 684
 685         res.class_inst = class_inst;
 686         res.method_inst = method_inst;
 687
 688         return res;
 689 }
 690
 691 /*
 692  * mono_class_inflate_generic_method:
 693  * @method: a generic method
 694  * @context: a generics context
 695  *
 696  * Instantiate the generic method @method using the generics context @context.
 697  *
 698  * Returns: the new instantiated method
 699  */
 700 MonoMethod *
 701 mono_class_inflate_generic_method (MonoMethod *method, MonoGenericContext *context)
 702 {
 703         return mono_class_inflate_generic_method_full (method, NULL, context);
 704 }
 705
 706 /**
 707  * mono_class_inflate_generic_method:
 708  *
 709  * Instantiate method @method with the generic context @context.
 710  * BEWARE: All non-trivial fields are invalid, including klass, signature, and header.
 711  *         Use mono_method_signature () and mono_method_get_header () to get the correct values.
 712  */
 713 MonoMethod*
 714 mono_class_inflate_generic_method_full (MonoMethod *method, MonoClass *klass_hint, MonoGenericContext *context)
 715 {
 716         MonoMethod *result;
 717         MonoMethodInflated *iresult, *cached;
 718         MonoMethodSignature *sig;
 719         MonoGenericContext tmp_context;
 720         gboolean is_mb_open = FALSE;
 721
 722         /* The `method' has already been instantiated before => we need to peel out the instantiation and create a new context */
 723         while (method->is_inflated) {
 724                 MonoGenericContext *method_context = mono_method_get_context (method);
 725                 MonoMethodInflated *imethod = (MonoMethodInflated *) method;
 726
 727                 tmp_context = inflate_generic_context (method_context, context);
 728                 context = &tmp_context;
 729
 730                 if (mono_metadata_generic_context_equal (method_context, context))
 731                         return method;
 732
 733                 method = imethod->declaring;
 734         }
 735
 736         if (!method->is_generic && !method->klass->generic_container)
 737                 return method;
 738
 739         /*
 740          * The reason for this hack is to fix the behavior of inflating generic methods that come from a MethodBuilder.
 741          * What happens is that instantiating a generic MethodBuilder with its own arguments should create a diferent object.
 742          * This is opposite to the way non-SRE MethodInfos behave.
 743          *
 744          * This happens, for example, when we want to emit a recursive generic method. Given the following C# code:
 745          *
 746          * void Example<T> () {
 747          *    Example<T> ();
 748          * }
 749          *
 750          * In Example, the method token must be encoded as: "void Example<!!0>()"
 751          *
 752          * The reference to the first generic argument, "!!0", must be explicit otherwise it won't be inflated
 753          * properly. To get that we need to inflate the MethodBuilder with its own arguments.
 754          *
 755          * On the other hand, inflating a non-SRE generic method with its own arguments should
 756          * return itself. For example:
 757          *
 758          * MethodInfo m = ... //m is a generic method definition
 759          * MethodInfo res = m.MakeGenericMethod (m.GetGenericArguments ());
 760          * res == m
 761          *
 762          * To allow such scenarios we must allow inflation of MethodBuilder to happen in a diferent way than
 763          * what happens with regular methods.
 764          *
 765          * There is one last touch to this madness, once a TypeBuilder is finished, IOW CreateType() is called,
 766          * everything should behave like a regular type or method.
 767          *
 768          */
 769         is_mb_open = method->is_generic &&
 770                 method->klass->image->dynamic && !method->klass->wastypebuilder && /* that is a MethodBuilder from an unfinished TypeBuilder */
 771                 context->method_inst == mono_method_get_generic_container (method)->context.method_inst; /* and it's been instantiated with its own arguments.  */
 772
 773         iresult = g_new0 (MonoMethodInflated, 1);
 774         iresult->context = *context;
 775         iresult->declaring = method;
 776         iresult->is_mb_open = is_mb_open;
 777
 778         if (!context->method_inst && method->is_generic)
 779                 iresult->context.method_inst = mono_method_get_generic_container (method)->context.method_inst;
 780
 781         if (!context->class_inst) {
 782                 g_assert (!iresult->declaring->klass->generic_class);
 783                 if (iresult->declaring->klass->generic_container)
 784                         iresult->context.class_inst = iresult->declaring->klass->generic_container->context.class_inst;
 785                 else if (iresult->declaring->klass->generic_class)
 786                         iresult->context.class_inst = iresult->declaring->klass->generic_class->context.class_inst;
 787         }
 788
 789         mono_loader_lock ();
 790         cached = mono_method_inflated_lookup (iresult, FALSE);
 791         if (cached) {
 792                 mono_loader_unlock ();
 793                 g_free (iresult);
 794                 return (MonoMethod*)cached;
 795         }
 796
 797         mono_stats.inflated_method_count++;
 798
 799         sig = mono_method_signature (method);
 800         if (sig->pinvoke) {
 801                 memcpy (&iresult->method.pinvoke, method, sizeof (MonoMethodPInvoke));
 802         } else {
 803                 memcpy (&iresult->method.normal, method, sizeof (MonoMethodNormal));
 804                 iresult->method.normal.header = NULL;
 805         }
 806
 807         result = (MonoMethod *) iresult;
 808         result->is_inflated = TRUE;
 809         result->is_generic = FALSE;
 810         result->signature = NULL;
 811
 812         if (!context->method_inst) {
 813                 /* Set the generic_container of the result to the generic_container of method */
 814                 MonoGenericContainer *generic_container = mono_method_get_generic_container (method);
 815
 816                 if (generic_container) {
 817                         result->is_generic = 1;
 818                         mono_method_set_generic_container (result, generic_container);
 819                 }
 820         }
 821
 822         if (!klass_hint || !klass_hint->generic_class ||
 823             klass_hint->generic_class->container_class != method->klass ||
 824             klass_hint->generic_class->context.class_inst != context->class_inst)
 825                 klass_hint = NULL;
 826
 827         if (method->klass->generic_container)
 828                 result->klass = klass_hint;
 829
 830         if (!result->klass) {
 831                 MonoType *inflated = inflate_generic_type (NULL, &method->klass->byval_arg, context);
 832                 result->klass = inflated ? mono_class_from_mono_type (inflated) : method->klass;
 833                 if (inflated)
 834                         mono_metadata_free_type (inflated);
 835         }
 836
 837         mono_method_inflated_lookup (iresult, TRUE);
 838         mono_loader_unlock ();
 839         return result;
 840 }
 841
 842 /**
 843  * mono_get_inflated_method:
 844  *
 845  * Obsolete.  We keep it around since it's mentioned in the public API.
 846  */
 847 MonoMethod*
 848 mono_get_inflated_method (MonoMethod *method)
 849 {
 850         return method;
 851 }
 852
 853 MonoGenericContext*
 854 mono_method_get_context (MonoMethod *method)
 855 {
 856         MonoMethodInflated *imethod;
 857         if (!method->is_inflated)
 858                 return NULL;
 859         imethod = (MonoMethodInflated *) method;
 860         return &imethod->context;
 861 }
 862
 863 /*
 864  * mono_method_get_generic_container:
 865  *
 866  *   Returns the generic container of METHOD, which should be a generic method definition.
 867  * Returns NULL if METHOD is not a generic method definition.
 868  * LOCKING: Acquires the loader lock.
 869  */
 870 MonoGenericContainer*
 871 mono_method_get_generic_container (MonoMethod *method)
 872 {
 873         MonoGenericContainer *container;
 874
 875         if (!method->is_generic)
 876                 return NULL;
 877
 878         mono_loader_lock ();
 879         container = mono_property_hash_lookup (method->klass->image->property_hash, method, MONO_METHOD_PROP_GENERIC_CONTAINER);
 880         mono_loader_unlock ();
 881         g_assert (container);
 882
 883         return container;
 884 }
 885
 886 /*
 887  * mono_method_set_generic_container:
 888  *
 889  *   Sets the generic container of METHOD to CONTAINER.
 890  * LOCKING: Acquires the loader lock.
 891  */
 892 void
 893 mono_method_set_generic_container (MonoMethod *method, MonoGenericContainer* container)
 894 {
 895         g_assert (method->is_generic);
 896
 897         mono_loader_lock ();
 898         mono_property_hash_insert (method->klass->image->property_hash, method, MONO_METHOD_PROP_GENERIC_CONTAINER, container);
 899         mono_loader_unlock ();
 900 }
 901
 902 /**
 903  * mono_class_find_enum_basetype:
 904  * @class: The enum class
 905  *
 906  *   Determine the basetype of an enum by iterating through its fields. We do this
 907  * in a separate function since it is cheaper than calling mono_class_setup_fields.
 908  */
 909 static MonoType*
 910 mono_class_find_enum_basetype (MonoClass *class)
 911 {
 912         MonoImage *m = class->image;
 913         const int top = class->field.count;
 914         int i;
 915
 916         g_assert (class->enumtype);
 917
 918         /*
 919          * Fetch all the field information.
 920          */
 921         for (i = 0; i < top; i++){
 922                 const char *sig;
 923                 guint32 cols [MONO_FIELD_SIZE];
 924                 int idx = class->field.first + i;
 925                 MonoGenericContainer *container = NULL;
 926                 MonoType *ftype;
 927
 928                 /* class->field.first and idx points into the fieldptr table */
 929                 mono_metadata_decode_table_row (m, MONO_TABLE_FIELD, idx, cols, MONO_FIELD_SIZE);
 930                 sig = mono_metadata_blob_heap (m, cols [MONO_FIELD_SIGNATURE]);
 931                 mono_metadata_decode_value (sig, &sig);
 932                 /* FIELD signature == 0x06 */
 933                 g_assert (*sig == 0x06);
 934                 if (class->generic_container)
 935                         container = class->generic_container;
 936                 else if (class->generic_class) {
 937                         MonoClass *gklass = class->generic_class->container_class;
 938
 939                         container = gklass->generic_container;
 940                         g_assert (container);
 941                 }
 942                 ftype = mono_metadata_parse_type_full (m, container, MONO_PARSE_FIELD, cols [MONO_FIELD_FLAGS], sig + 1, &sig);
 943                 if (!ftype)
 944                         return NULL;
 945                 if (class->generic_class) {
 946                         //FIXME do we leak here?
 947                         ftype = mono_class_inflate_generic_type (ftype, mono_class_get_context (class));
 948                         ftype->attrs = cols [MONO_FIELD_FLAGS];
 949                 }
 950
 951                 if (class->enumtype && !(cols [MONO_FIELD_FLAGS] & FIELD_ATTRIBUTE_STATIC))
 952                         return ftype;
 953         }
 954
 955         return NULL;
 956 }
 957
 958 /**
 959  * mono_class_setup_fields:
 960  * @class: The class to initialize
 961  *
 962  * Initializes the class->fields.
 963  * LOCKING: Assumes the loader lock is held.
 964  */
 965 static void
 966 mono_class_setup_fields (MonoClass *class)
 967 {
 968         MonoImage *m = class->image;
 969         int top = class->field.count;
 970         guint32 layout = class->flags & TYPE_ATTRIBUTE_LAYOUT_MASK;
 971         int i, blittable = TRUE;
 972         guint32 real_size = 0;
 973         guint32 packing_size = 0;
 974         gboolean explicit_size;
 975         MonoClassField *field;
 976         MonoGenericContainer *container = NULL;
 977         MonoClass *gklass = NULL;
 978
 979         if (class->size_inited)
 980                 return;
 981
 982         if (class->generic_class && class->generic_class->container_class->image->dynamic && !class->generic_class->container_class->wastypebuilder) {
 983                 /*
 984                  * This happens when a generic instance of an unfinished generic typebuilder
 985                  * is used as an element type for creating an array type. We can't initialize
 986                  * the fields of this class using the fields of gklass, since gklass is not
 987                  * finished yet, fields could be added to it later.
 988                  */
 989                 return;
 990         }
 991
 992         if (class->generic_class) {
 993                 MonoClass *gklass = class->generic_class->container_class;
 994                 mono_class_setup_fields (gklass);
 995                 top = gklass->field.count;
 996                 class->field.count = gklass->field.count;
 997         }
 998
 999         class->instance_size = 0;
1000         if (!class->rank)
1001                 class->sizes.class_size = 0;
1002
1003         if (class->parent) {
1004                 /* For generic instances, class->parent might not have been initialized */
1005                 mono_class_init (class->parent);
1006                 if (!class->parent->size_inited)
1007                         mono_class_setup_fields (class->parent);
1008                 class->instance_size += class->parent->instance_size;
1009                 class->min_align = class->parent->min_align;
1010                 /* we use |= since it may have been set already */
1011                 class->has_references |= class->parent->has_references;
1012                 blittable = class->parent->blittable;
1013         } else {
1014                 class->instance_size = sizeof (MonoObject);
1015                 class->min_align = 1;
1016         }
1017
1018         if (class->simd_type)
1019                 class->min_align = 16;
1020
1021         /* Get the real size */
1022         explicit_size = mono_metadata_packing_from_typedef (class->image, class->type_token, &packing_size, &real_size);
1023
1024         if (explicit_size) {
1025                 g_assert ((packing_size & 0xfffffff0) == 0);
1026                 class->packing_size = packing_size;
1027                 real_size += class->instance_size;
1028         }
1029
1030         if (!top) {
1031                 if (explicit_size && real_size) {
1032                         class->instance_size = MAX (real_size, class->instance_size);
1033                 }
1034                 class->size_inited = 1;
1035                 class->blittable = blittable;
1036                 return;
1037         }
1038
1039         if (layout == TYPE_ATTRIBUTE_AUTO_LAYOUT)
1040                 blittable = FALSE;
1041
1042         /* Prevent infinite loops if the class references itself */
1043         class->size_inited = 1;
1044
1045         class->fields = mono_image_alloc0 (class->image, sizeof (MonoClassField) * top);
1046
1047         if (class->generic_container) {
1048                 container = class->generic_container;
1049         } else if (class->generic_class) {
1050                 gklass = class->generic_class->container_class;
1051                 container = gklass->generic_container;
1052                 g_assert (container);
1053
1054                 mono_class_setup_fields (gklass);
1055
1056                 if (gklass->exception_type) {
1057                         mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL);
1058                         return;
1059                 }
1060         }
1061
1062         /*
1063          * Fetch all the field information.
1064          */
1065         for (i = 0; i < top; i++){
1066                 int idx = class->field.first + i;
1067                 field = &class->fields [i];
1068
1069                 field->parent = class;
1070
1071                 if (class->generic_class) {
1072                         MonoClassField *gfield = &gklass->fields [i];
1073
1074                         field->name = mono_field_get_name (gfield);
1075                         /*This memory must come from the image mempool as we don't have a chance to free it.*/
1076                         field->type = mono_class_inflate_generic_type_with_mempool_no_copy (class->image->mempool, gfield->type, mono_class_get_context (class));
1077                         g_assert (field->type->attrs == gfield->type->attrs);
1078                         if (mono_field_is_deleted (field))
1079                                 continue;
1080                         field->offset = gfield->offset;
1081                 } else {
1082                         const char *sig;
1083                         guint32 cols [MONO_FIELD_SIZE];
1084
1085                         /* class->field.first and idx points into the fieldptr table */
1086                         mono_metadata_decode_table_row (m, MONO_TABLE_FIELD, idx, cols, MONO_FIELD_SIZE);
1087                         /* The name is needed for fieldrefs */
1088                         field->name = mono_metadata_string_heap (m, cols [MONO_FIELD_NAME]);
1089                         sig = mono_metadata_blob_heap (m, cols [MONO_FIELD_SIGNATURE]);
1090                         mono_metadata_decode_value (sig, &sig);
1091                         /* FIELD signature == 0x06 */
1092                         g_assert (*sig == 0x06);
1093                         field->type = mono_metadata_parse_type_full (m, container, MONO_PARSE_FIELD, cols [MONO_FIELD_FLAGS], sig + 1, &sig);
1094                         if (!field->type) {
1095                                 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL);
1096                                 break;
1097                         }
1098                         if (mono_field_is_deleted (field))
1099                                 continue;
1100                         if (layout == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) {
1101                                 guint32 offset;
1102                                 mono_metadata_field_info (m, idx, &offset, NULL, NULL);
1103                                 field->offset = offset;
1104                                 if (field->offset == (guint32)-1 && !(field->type->attrs & FIELD_ATTRIBUTE_STATIC))
1105                                         g_warning ("%s not initialized correctly (missing field layout info for %s)",
1106                                                            class->name, mono_field_get_name (field));
1107                         }
1108                 }
1109
1110                 /* Only do these checks if we still think this type is blittable */
1111                 if (blittable && !(field->type->attrs & FIELD_ATTRIBUTE_STATIC)) {
1112                         if (field->type->byref || MONO_TYPE_IS_REFERENCE (field->type)) {
1113                                 blittable = FALSE;
1114                         } else {
1115                                 MonoClass *field_class = mono_class_from_mono_type (field->type);
1116                                 if (field_class)
1117                                         mono_class_setup_fields (field_class);
1118                                 if (!field_class || !field_class->blittable)
1119                                         blittable = FALSE;
1120                         }
1121                 }
1122
1123                 if (class->enumtype && !(field->type->attrs & FIELD_ATTRIBUTE_STATIC)) {
1124                         class->enum_basetype = field->type;
1125                         class->cast_class = class->element_class = mono_class_from_mono_type (class->enum_basetype);
1126                         blittable = class->element_class->blittable;
1127                 }
1128
1129                 /* The def_value of fields is compute lazily during vtable creation */
1130         }
1131
1132         if (class == mono_defaults.string_class)
1133                 blittable = FALSE;
1134
1135         class->blittable = blittable;
1136
1137         if (class->enumtype && !class->enum_basetype) {
1138                 if (!((strcmp (class->name, "Enum") == 0) && (strcmp (class->name_space, "System") == 0)))
1139                         G_BREAKPOINT ();
1140         }
1141         if (explicit_size && real_size) {
1142                 class->instance_size = MAX (real_size, class->instance_size);
1143         }
1144
1145         if (class->exception_type)
1146                 return;
1147         mono_class_layout_fields (class);
1148 }
1149
1150 /**
1151  * mono_class_setup_fields_locking:
1152  * @class: The class to initialize
1153  *
1154  * Initializes the class->fields array of fields.
1155  * Aquires the loader lock.
1156  */
1157 static void
1158 mono_class_setup_fields_locking (MonoClass *class)
1159 {
1160         mono_loader_lock ();
1161         mono_class_setup_fields (class);
1162         mono_loader_unlock ();
1163 }
1164
1165 /*
1166  * mono_class_has_references:
1167  *
1168  *   Returns whenever @klass->has_references is set, initializing it if needed.
1169  * Aquires the loader lock.
1170  */
1171 static gboolean
1172 mono_class_has_references (MonoClass *klass)
1173 {
1174         if (klass->init_pending) {
1175                 /* Be conservative */
1176                 return TRUE;
1177         } else {
1178                 mono_class_init (klass);
1179
1180                 return klass->has_references;
1181         }
1182 }
1183
1184 /* useful until we keep track of gc-references in corlib etc. */
1185 #ifdef HAVE_SGEN_GC
1186 #define IS_GC_REFERENCE(t) FALSE
1187 #else
1188 #define IS_GC_REFERENCE(t) ((t)->type == MONO_TYPE_U && class->image == mono_defaults.corlib)
1189 #endif
1190
1191 /*
1192  * mono_type_get_basic_type_from_generic:
1193  * @type: a type
1194  *
1195  * Returns a closed type corresponding to the possibly open type
1196  * passed to it.
1197  */
1198 MonoType*
1199 mono_type_get_basic_type_from_generic (MonoType *type)
1200 {
1201         /* When we do generic sharing we let type variables stand for reference types. */
1202         if (!type->byref && (type->type == MONO_TYPE_VAR || type->type == MONO_TYPE_MVAR))
1203                 return &mono_defaults.object_class->byval_arg;
1204         return type;
1205 }
1206
1207 /*
1208  * mono_class_layout_fields:
1209  * @class: a class
1210  *
1211  * Compute the placement of fields inside an object or struct, according to
1212  * the layout rules and set the following fields in @class:
1213  *  - has_references (if the class contains instance references firled or structs that contain references)
1214  *  - has_static_refs (same, but for static fields)
1215  *  - instance_size (size of the object in memory)
1216  *  - class_size (size needed for the static fields)
1217  *  - size_inited (flag set when the instance_size is set)
1218  *
1219  * LOCKING: this is supposed to be called with the loader lock held.
1220  */
1221 void
1222 mono_class_layout_fields (MonoClass *class)
1223 {
1224         int i;
1225         const int top = class->field.count;
1226         guint32 layout = class->flags & TYPE_ATTRIBUTE_LAYOUT_MASK;
1227         guint32 pass, passes, real_size;
1228         gboolean gc_aware_layout = FALSE;
1229         MonoClassField *field;
1230
1231         /*
1232          * When we do generic sharing we need to have layout
1233          * information for open generic classes (either with a generic
1234          * context containing type variables or with a generic
1235          * container), so we don't return in that case anymore.
1236          */
1237
1238         /*
1239          * Enable GC aware auto layout: in this mode, reference
1240          * fields are grouped together inside objects, increasing collector
1241          * performance.
1242          * Requires that all classes whose layout is known to native code be annotated
1243          * with [StructLayout (LayoutKind.Sequential)]
1244          * Value types have gc_aware_layout disabled by default, as per
1245          * what the default is for other runtimes.
1246          */
1247          /* corlib is missing [StructLayout] directives in many places */
1248         if (layout == TYPE_ATTRIBUTE_AUTO_LAYOUT) {
1249                 if (class->image != mono_defaults.corlib &&
1250                         class->byval_arg.type != MONO_TYPE_VALUETYPE)
1251                         gc_aware_layout = TRUE;
1252                 /* from System.dll, used in metadata/process.h */
1253                 if (strcmp (class->name, "ProcessStartInfo") == 0)
1254                         gc_aware_layout = FALSE;
1255         }
1256
1257         /* Compute klass->has_references */
1258         /*
1259          * Process non-static fields first, since static fields might recursively
1260          * refer to the class itself.
1261          */
1262         for (i = 0; i < top; i++) {
1263                 MonoType *ftype;
1264
1265                 field = &class->fields [i];
1266
1267                 if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC)) {
1268                         ftype = mono_type_get_underlying_type (field->type);
1269                         ftype = mono_type_get_basic_type_from_generic (ftype);
1270                         if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype)))))
1271                                 class->has_references = TRUE;
1272                 }
1273         }
1274
1275         for (i = 0; i < top; i++) {
1276                 MonoType *ftype;
1277
1278                 field = &class->fields [i];
1279
1280                 if (field->type->attrs & FIELD_ATTRIBUTE_STATIC) {
1281                         ftype = mono_type_get_underlying_type (field->type);
1282                         ftype = mono_type_get_basic_type_from_generic (ftype);
1283                         if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype)))))
1284                                 class->has_static_refs = TRUE;
1285                 }
1286         }
1287
1288         for (i = 0; i < top; i++) {
1289                 MonoType *ftype;
1290
1291                 field = &class->fields [i];
1292
1293                 ftype = mono_type_get_underlying_type (field->type);
1294                 ftype = mono_type_get_basic_type_from_generic (ftype);
1295                 if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype))))) {
1296                         if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
1297                                 class->has_static_refs = TRUE;
1298                         else
1299                                 class->has_references = TRUE;
1300                 }
1301         }
1302
1303         /*
1304          * Compute field layout and total size (not considering static fields)
1305          */
1306
1307         switch (layout) {
1308         case TYPE_ATTRIBUTE_AUTO_LAYOUT:
1309         case TYPE_ATTRIBUTE_SEQUENTIAL_LAYOUT:
1310
1311                 if (gc_aware_layout)
1312                         passes = 2;
1313                 else
1314                         passes = 1;
1315
1316                 if (layout != TYPE_ATTRIBUTE_AUTO_LAYOUT)
1317                         passes = 1;
1318
1319                 if (class->parent)
1320                         real_size = class->parent->instance_size;
1321                 else
1322                         real_size = sizeof (MonoObject);
1323
1324                 for (pass = 0; pass < passes; ++pass) {
1325                         for (i = 0; i < top; i++){
1326                                 gint32 align;
1327                                 guint32 size;
1328                                 MonoType *ftype;
1329
1330                                 field = &class->fields [i];
1331
1332                                 if (mono_field_is_deleted (field))
1333                                         continue;
1334                                 if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
1335                                         continue;
1336
1337                                 ftype = mono_type_get_underlying_type (field->type);
1338                                 ftype = mono_type_get_basic_type_from_generic (ftype);
1339                                 if (gc_aware_layout) {
1340                                         if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype))))) {
1341                                                 if (pass == 1)
1342                                                         continue;
1343                                         } else {
1344                                                 if (pass == 0)
1345                                                         continue;
1346                                         }
1347                                 }
1348
1349                                 if ((top == 1) && (class->instance_size == sizeof (MonoObject)) &&
1350                                         (strcmp (mono_field_get_name (field), "$PRIVATE$") == 0)) {
1351                                         /* This field is a hack inserted by MCS to empty structures */
1352                                         continue;
1353                                 }
1354
1355                                 size = mono_type_size (field->type, &align);
1356
1357                                 /* FIXME (LAMESPEC): should we also change the min alignment according to pack? */
1358                                 align = class->packing_size ? MIN (class->packing_size, align): align;
1359                                 /* if the field has managed references, we need to force-align it
1360                                  * see bug #77788
1361                                  */
1362                                 if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype)))))
1363                                         align = MAX (align, sizeof (gpointer));
1364
1365                                 class->min_align = MAX (align, class->min_align);
1366                                 field->offset = real_size;
1367                                 field->offset += align - 1;
1368                                 field->offset &= ~(align - 1);
1369                                 real_size = field->offset + size;
1370                         }
1371
1372                         class->instance_size = MAX (real_size, class->instance_size);
1373
1374                         if (class->instance_size & (class->min_align - 1)) {
1375                                 class->instance_size += class->min_align - 1;
1376                                 class->instance_size &= ~(class->min_align - 1);
1377                         }
1378                 }
1379                 break;
1380         case TYPE_ATTRIBUTE_EXPLICIT_LAYOUT:
1381                 real_size = 0;
1382                 for (i = 0; i < top; i++) {
1383                         gint32 align;
1384                         guint32 size;
1385                         MonoType *ftype;
1386
1387                         field = &class->fields [i];
1388
1389                         /*
1390                          * There must be info about all the fields in a type if it
1391                          * uses explicit layout.
1392                          */
1393
1394                         if (mono_field_is_deleted (field))
1395                                 continue;
1396                         if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
1397                                 continue;
1398
1399                         size = mono_type_size (field->type, &align);
1400                         class->min_align = MAX (align, class->min_align);
1401
1402                         /*
1403                          * When we get here, field->offset is already set by the
1404                          * loader (for either runtime fields or fields loaded from metadata).
1405                          * The offset is from the start of the object: this works for both
1406                          * classes and valuetypes.
1407                          */
1408                         field->offset += sizeof (MonoObject);
1409                         ftype = mono_type_get_underlying_type (field->type);
1410                         ftype = mono_type_get_basic_type_from_generic (ftype);
1411                         if (MONO_TYPE_IS_REFERENCE (ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && mono_class_has_references (mono_class_from_mono_type (ftype))))) {
1412                                 if (field->offset % sizeof (gpointer)) {
1413                                         mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL);
1414                                 }
1415                         }
1416
1417                         /*
1418                          * Calc max size.
1419                          */
1420                         real_size = MAX (real_size, size + field->offset);
1421                 }
1422                 class->instance_size = MAX (real_size, class->instance_size);
1423                 break;
1424         }
1425
1426         if (layout != TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) {
1427                 /*
1428                  * For small structs, set min_align to at least the struct size to improve
1429                  * performance, and since the JIT memset/memcpy code assumes this and generates
1430                  * unaligned accesses otherwise. See #78990 for a testcase.
1431                  */
1432                 if (class->instance_size <= sizeof (MonoObject) + sizeof (gpointer))
1433                         class->min_align = MAX (class->min_align, class->instance_size - sizeof (MonoObject));
1434         }
1435
1436         class->size_inited = 1;
1437
1438         /*
1439          * Compute static field layout and size
1440          */
1441         for (i = 0; i < top; i++){
1442                 gint32 align;
1443                 guint32 size;
1444
1445                 field = &class->fields [i];
1446
1447                 if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC) || field->type->attrs & FIELD_ATTRIBUTE_LITERAL)
1448                         continue;
1449                 if (mono_field_is_deleted (field))
1450                         continue;
1451
1452                 size = mono_type_size (field->type, &align);
1453                 field->offset = class->sizes.class_size;
1454                 field->offset += align - 1;
1455                 field->offset &= ~(align - 1);
1456                 class->sizes.class_size = field->offset + size;
1457         }
1458 }
1459
1460 static MonoMethod*
1461 create_array_method (MonoClass *class, const char *name, MonoMethodSignature *sig)
1462 {
1463         MonoMethod *method;
1464
1465         method = (MonoMethod *) mono_image_alloc0 (class->image, sizeof (MonoMethodPInvoke));
1466         method->klass = class;
1467         method->flags = METHOD_ATTRIBUTE_PUBLIC;
1468         method->iflags = METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL;
1469         method->signature = sig;
1470         method->name = name;
1471         method->slot = -1;
1472         /* .ctor */
1473         if (name [0] == '.') {
1474                 method->flags |= METHOD_ATTRIBUTE_RT_SPECIAL_NAME | METHOD_ATTRIBUTE_SPECIAL_NAME;
1475         } else {
1476                 method->iflags |= METHOD_IMPL_ATTRIBUTE_RUNTIME;
1477         }
1478         return method;
1479 }
1480
1481 /*
1482  * mono_class_setup_methods:
1483  * @class: a class
1484  *
1485  *   Initializes the 'methods' array in the klass.
1486  * Calling this method should be avoided if possible since it allocates a lot
1487  * of long-living MonoMethod structures.
1488  * Methods belonging to an interface are assigned a sequential slot starting
1489  * from 0.
1490  */
1491 void
1492 mono_class_setup_methods (MonoClass *class)
1493 {
1494         int i;
1495         MonoMethod **methods;
1496
1497         if (class->methods)
1498                 return;
1499
1500         mono_loader_lock ();
1501
1502         if (class->methods) {
1503                 mono_loader_unlock ();
1504                 return;
1505         }
1506
1507         if (class->generic_class) {
1508                 MonoClass *gklass = class->generic_class->container_class;
1509
1510                 mono_class_init (gklass);
1511                 mono_class_setup_methods (gklass);
1512
1513                 /* The + 1 makes this always non-NULL to pass the check in mono_class_setup_methods () */
1514                 class->method.count = gklass->method.count;
1515                 methods = g_new0 (MonoMethod *, class->method.count + 1);
1516
1517                 for (i = 0; i < class->method.count; i++) {
1518                         methods [i] = mono_class_inflate_generic_method_full (
1519                                 gklass->methods [i], class, mono_class_get_context (class));
1520                 }
1521         } else if (class->rank) {
1522                 MonoMethod *amethod;
1523                 MonoMethodSignature *sig;
1524                 int count_generic = 0, first_generic = 0;
1525                 int method_num = 0;
1526
1527                 class->method.count = 3 + (class->rank > 1? 2: 1);
1528
1529                 if (class->interface_count) {
1530                         count_generic = generic_array_methods (class);
1531                         first_generic = class->method.count;
1532                         class->method.count += class->interface_count * count_generic;
1533                 }
1534
1535                 methods = mono_image_alloc0 (class->image, sizeof (MonoMethod*) * class->method.count);
1536
1537                 sig = mono_metadata_signature_alloc (class->image, class->rank);
1538                 sig->ret = &mono_defaults.void_class->byval_arg;
1539                 sig->pinvoke = TRUE;
1540                 sig->hasthis = TRUE;
1541                 for (i = 0; i < class->rank; ++i)
1542                         sig->params [i] = &mono_defaults.int32_class->byval_arg;
1543
1544                 amethod = create_array_method (class, ".ctor", sig);
1545                 methods [method_num++] = amethod;
1546                 if (class->rank > 1) {
1547                         sig = mono_metadata_signature_alloc (class->image, class->rank * 2);
1548                         sig->ret = &mono_defaults.void_class->byval_arg;
1549                         sig->pinvoke = TRUE;
1550                         sig->hasthis = TRUE;
1551                         for (i = 0; i < class->rank * 2; ++i)
1552                                 sig->params [i] = &mono_defaults.int32_class->byval_arg;
1553
1554                         amethod = create_array_method (class, ".ctor", sig);
1555                         methods [method_num++] = amethod;
1556                 }
1557                 /* element Get (idx11, [idx2, ...]) */
1558                 sig = mono_metadata_signature_alloc (class->image, class->rank);
1559                 sig->ret = &class->element_class->byval_arg;
1560                 sig->pinvoke = TRUE;
1561                 sig->hasthis = TRUE;
1562                 for (i = 0; i < class->rank; ++i)
1563                         sig->params [i] = &mono_defaults.int32_class->byval_arg;
1564                 amethod = create_array_method (class, "Get", sig);
1565                 methods [method_num++] = amethod;
1566                 /* element& Address (idx11, [idx2, ...]) */
1567                 sig = mono_metadata_signature_alloc (class->image, class->rank);
1568                 sig->ret = &class->element_class->this_arg;
1569                 sig->pinvoke = TRUE;
1570                 sig->hasthis = TRUE;
1571                 for (i = 0; i < class->rank; ++i)
1572                         sig->params [i] = &mono_defaults.int32_class->byval_arg;
1573                 amethod = create_array_method (class, "Address", sig);
1574                 methods [method_num++] = amethod;
1575                 /* void Set (idx11, [idx2, ...], element) */
1576                 sig = mono_metadata_signature_alloc (class->image, class->rank + 1);
1577                 sig->ret = &mono_defaults.void_class->byval_arg;
1578                 sig->pinvoke = TRUE;
1579                 sig->hasthis = TRUE;
1580                 for (i = 0; i < class->rank; ++i)
1581                         sig->params [i] = &mono_defaults.int32_class->byval_arg;
1582                 sig->params [i] = &class->element_class->byval_arg;
1583                 amethod = create_array_method (class, "Set", sig);
1584                 methods [method_num++] = amethod;
1585
1586                 for (i = 0; i < class->interface_count; i++)
1587                         setup_generic_array_ifaces (class, class->interfaces [i], methods, first_generic + i * count_generic);
1588         } else {
1589                 methods = mono_image_alloc (class->image, sizeof (MonoMethod*) * class->method.count);
1590                 for (i = 0; i < class->method.count; ++i) {
1591                         int idx = mono_metadata_translate_token_index (class->image, MONO_TABLE_METHOD, class->method.first + i + 1);
1592                         methods [i] = mono_get_method (class->image, MONO_TOKEN_METHOD_DEF | idx, class);
1593                 }
1594         }
1595
1596         if (MONO_CLASS_IS_INTERFACE (class))
1597                 for (i = 0; i < class->method.count; ++i)
1598                         methods [i]->slot = i;
1599
1600         /* Needed because of the double-checking locking pattern */
1601         mono_memory_barrier ();
1602
1603         class->methods = methods;
1604
1605         if (mono_debugger_class_loaded_methods_func)
1606                 mono_debugger_class_loaded_methods_func (class);
1607
1608         mono_loader_unlock ();
1609 }
1610
1611 /*
1612  * mono_class_get_method_by_index:
1613  *
1614  *   Returns class->methods [index], initializing class->methods if neccesary.
1615  *
1616  * LOCKING: Acquires the loader lock.
1617  */
1618 MonoMethod*
1619 mono_class_get_method_by_index (MonoClass *class, int index)
1620 {
1621         /* Avoid calling setup_methods () if possible */
1622         if (class->generic_class && !class->methods) {
1623                 MonoClass *gklass = class->generic_class->container_class;
1624                 MonoMethod *m;
1625
1626                 m = mono_class_inflate_generic_method_full (
1627                                 gklass->methods [index], class, mono_class_get_context (class));
1628                 /*
1629                  * If setup_methods () is called later for this class, no duplicates are created,
1630                  * since inflate_generic_method guarantees that only one instance of a method
1631                  * is created for each context.
1632                  */
1633                 /*
1634                 mono_class_setup_methods (class);
1635                 g_assert (m == class->methods [index]);
1636                 */
1637                 return m;
1638         } else {
1639                 mono_class_setup_methods (class);
1640                 g_assert (index >= 0 && index < class->method.count);
1641                 return class->methods [index];
1642         }
1643 }
1644
1645 /*
1646  * mono_class_get_inflated_method:
1647  *
1648  *   Given an inflated class CLASS and a method METHOD which should be a method of
1649  * CLASS's generic definition, return the inflated method corresponding to METHOD.
1650  */
1651 MonoMethod*
1652 mono_class_get_inflated_method (MonoClass *class, MonoMethod *method)
1653 {
1654         MonoClass *gklass = class->generic_class->container_class;
1655         int i;
1656
1657         mono_class_setup_methods (gklass);
1658         for (i = 0; i < gklass->method.count; ++i) {
1659                 if (gklass->methods [i] == method) {
1660                         if (class->methods)
1661                                 return class->methods [i];
1662                         else
1663                                 return mono_class_inflate_generic_method_full (gklass->methods [i], class, mono_class_get_context (class));
1664                 }
1665         }
1666
1667         return NULL;
1668 }
1669
1670 /*
1671  * mono_class_get_vtable_entry:
1672  *
1673  *   Returns class->vtable [offset], computing it if neccesary.
1674  * LOCKING: Acquires the loader lock.
1675  */
1676 MonoMethod*
1677 mono_class_get_vtable_entry (MonoClass *class, int offset)
1678 {
1679         if (class->generic_class) {
1680                 MonoClass *gklass = class->generic_class->container_class;
1681                 mono_class_setup_vtable (gklass);
1682                 if (gklass->vtable [offset]->wrapper_type != MONO_WRAPPER_STATIC_RGCTX_INVOKE)
1683                         return mono_class_inflate_generic_method_full (gklass->vtable [offset], class, mono_class_get_context (class));
1684         }
1685
1686         if (class->rank == 1) {
1687                 /*
1688                  * szarrays do not overwrite any methods of Array, so we can avoid
1689                  * initializing their vtables in some cases.
1690                  */
1691                 mono_class_setup_vtable (class->parent);
1692                 if (offset < class->parent->vtable_size)
1693                         return class->parent->vtable [offset];
1694         }
1695
1696         mono_class_setup_vtable (class);
1697         return class->vtable [offset];
1698 }
1699
1700 static void
1701 mono_class_setup_properties (MonoClass *class)
1702 {
1703         guint startm, endm, i, j;
1704         guint32 cols [MONO_PROPERTY_SIZE];
1705         MonoTableInfo *msemt = &class->image->tables [MONO_TABLE_METHODSEMANTICS];
1706         MonoProperty *properties;
1707         guint32 last;
1708
1709         if (class->properties)
1710                 return;
1711
1712         mono_loader_lock ();
1713
1714         if (class->properties) {
1715                 mono_loader_unlock ();
1716                 return;
1717         }
1718
1719         if (class->generic_class) {
1720                 MonoClass *gklass = class->generic_class->container_class;
1721
1722                 mono_class_init (gklass);
1723                 mono_class_setup_properties (gklass);
1724
1725                 class->property = gklass->property;
1726
1727                 properties = g_new0 (MonoProperty, class->property.count + 1);
1728
1729                 for (i = 0; i < class->property.count; i++) {
1730                         MonoProperty *prop = &properties [i];
1731
1732                         *prop = gklass->properties [i];
1733
1734                         if (prop->get)
1735                                 prop->get = mono_class_inflate_generic_method_full (
1736                                         prop->get, class, mono_class_get_context (class));
1737                         if (prop->set)
1738                                 prop->set = mono_class_inflate_generic_method_full (
1739                                         prop->set, class, mono_class_get_context (class));
1740
1741                         prop->parent = class;
1742                 }
1743         } else {
1744                 class->property.first = mono_metadata_properties_from_typedef (class->image, mono_metadata_token_index (class->type_token) - 1, &last);
1745                 class->property.count = last - class->property.first;
1746
1747                 if (class->property.count)
1748                         mono_class_setup_methods (class);
1749
1750                 properties = mono_image_alloc0 (class->image, sizeof (MonoProperty) * class->property.count);
1751                 for (i = class->property.first; i < last; ++i) {
1752                         mono_metadata_decode_table_row (class->image, MONO_TABLE_PROPERTY, i, cols, MONO_PROPERTY_SIZE);
1753                         properties [i - class->property.first].parent = class;
1754                         properties [i - class->property.first].attrs = cols [MONO_PROPERTY_FLAGS];
1755                         properties [i - class->property.first].name = mono_metadata_string_heap (class->image, cols [MONO_PROPERTY_NAME]);
1756
1757                         startm = mono_metadata_methods_from_property (class->image, i, &endm);
1758                         for (j = startm; j < endm; ++j) {
1759                                 MonoMethod *method;
1760
1761                                 mono_metadata_decode_row (msemt, j, cols, MONO_METHOD_SEMA_SIZE);
1762
1763                                 if (class->image->uncompressed_metadata)
1764                                         /* It seems like the MONO_METHOD_SEMA_METHOD column needs no remapping */
1765                                         method = mono_get_method (class->image, MONO_TOKEN_METHOD_DEF | cols [MONO_METHOD_SEMA_METHOD], class);
1766                                 else
1767                                         method = class->methods [cols [MONO_METHOD_SEMA_METHOD] - 1 - class->method.first];
1768
1769                                 switch (cols [MONO_METHOD_SEMA_SEMANTICS]) {
1770                                 case METHOD_SEMANTIC_SETTER:
1771                                         properties [i - class->property.first].set = method;
1772                                         break;
1773                                 case METHOD_SEMANTIC_GETTER:
1774                                         properties [i - class->property.first].get = method;
1775                                         break;
1776                                 default:
1777                                         break;
1778                                 }
1779                         }
1780                 }
1781         }
1782         /*Flush any pending writes as we do double checked locking on class->properties */
1783         mono_memory_barrier ();
1784
1785         /* Leave this assignment as the last op in the function */
1786         class->properties = properties;
1787
1788         mono_loader_unlock ();
1789 }
1790
1791 static MonoMethod**
1792 inflate_method_listz (MonoMethod **methods, MonoClass *class, MonoGenericContext *context)
1793 {
1794         MonoMethod **om, **retval;
1795         int count;
1796
1797         for (om = methods, count = 0; *om; ++om, ++count)
1798                 ;
1799
1800         retval = g_new0 (MonoMethod*, count + 1);
1801         count = 0;
1802         for (om = methods, count = 0; *om; ++om, ++count)
1803                 retval [count] = mono_class_inflate_generic_method_full (*om, class, context);
1804
1805         return retval;
1806 }
1807
1808 static void
1809 mono_class_setup_events (MonoClass *class)
1810 {
1811         guint startm, endm, i, j;
1812         guint32 cols [MONO_EVENT_SIZE];
1813         MonoTableInfo *msemt = &class->image->tables [MONO_TABLE_METHODSEMANTICS];
1814         guint32 last;
1815         MonoEvent *events;
1816
1817         if (class->events)
1818                 return;
1819
1820         mono_loader_lock ();
1821
1822         if (class->events) {
1823                 mono_loader_unlock ();
1824                 return;
1825         }
1826
1827         if (class->generic_class) {
1828                 MonoClass *gklass = class->generic_class->container_class;
1829                 MonoGenericContext *context;
1830
1831                 mono_class_setup_events (gklass);
1832                 class->event = gklass->event;
1833
1834                 class->events = g_new0 (MonoEvent, class->event.count);
1835
1836                 if (class->event.count)
1837                         context = mono_class_get_context (class);
1838
1839                 for (i = 0; i < class->event.count; i++) {
1840                         MonoEvent *event = &class->events [i];
1841                         MonoEvent *gevent = &gklass->events [i];
1842
1843                         event->parent = class;
1844                         event->name = gevent->name;
1845                         event->add = gevent->add ? mono_class_inflate_generic_method_full (gevent->add, class, context) : NULL;
1846                         event->remove = gevent->remove ? mono_class_inflate_generic_method_full (gevent->remove, class, context) : NULL;
1847                         event->raise = gevent->raise ? mono_class_inflate_generic_method_full (gevent->raise, class, context) : NULL;
1848                         event->other = gevent->other ? inflate_method_listz (gevent->other, class, context) : NULL;
1849                         event->attrs = gevent->attrs;
1850                 }
1851
1852                 mono_loader_unlock ();
1853                 return;
1854         }
1855
1856         class->event.first = mono_metadata_events_from_typedef (class->image, mono_metadata_token_index (class->type_token) - 1, &last);
1857         class->event.count = last - class->event.first;
1858
1859         if (class->event.count)
1860                 mono_class_setup_methods (class);
1861
1862         events = mono_image_alloc0 (class->image, sizeof (MonoEvent) * class->event.count);
1863         for (i = class->event.first; i < last; ++i) {
1864                 MonoEvent *event = &events [i - class->event.first];
1865
1866                 mono_metadata_decode_table_row (class->image, MONO_TABLE_EVENT, i, cols, MONO_EVENT_SIZE);
1867                 event->parent = class;
1868                 event->attrs = cols [MONO_EVENT_FLAGS];
1869                 event->name = mono_metadata_string_heap (class->image, cols [MONO_EVENT_NAME]);
1870
1871                 startm = mono_metadata_methods_from_event (class->image, i, &endm);
1872                 for (j = startm; j < endm; ++j) {
1873                         MonoMethod *method;
1874
1875                         mono_metadata_decode_row (msemt, j, cols, MONO_METHOD_SEMA_SIZE);
1876
1877                         if (class->image->uncompressed_metadata)
1878                                 /* It seems like the MONO_METHOD_SEMA_METHOD column needs no remapping */
1879                                 method = mono_get_method (class->image, MONO_TOKEN_METHOD_DEF | cols [MONO_METHOD_SEMA_METHOD], class);
1880                         else
1881                                 method = class->methods [cols [MONO_METHOD_SEMA_METHOD] - 1 - class->method.first];
1882
1883                         switch (cols [MONO_METHOD_SEMA_SEMANTICS]) {
1884                         case METHOD_SEMANTIC_ADD_ON:
1885                                 event->add = method;
1886                                 break;
1887                         case METHOD_SEMANTIC_REMOVE_ON:
1888                                 event->remove = method;
1889                                 break;
1890                         case METHOD_SEMANTIC_FIRE:
1891                                 event->raise = method;
1892                                 break;
1893                         case METHOD_SEMANTIC_OTHER: {
1894                                 int n = 0;
1895
1896                                 if (event->other == NULL) {
1897                                         event->other = g_new0 (MonoMethod*, 2);
1898                                 } else {
1899                                         while (event->other [n])
1900                                                 n++;
1901                                         event->other = g_realloc (event->other, (n + 2) * sizeof (MonoMethod*));
1902                                 }
1903                                 event->other [n] = method;
1904                                 /* NULL terminated */
1905                                 event->other [n + 1] = NULL;
1906                                 break;
1907                         }
1908                         default:
1909                                 break;
1910                         }
1911                 }
1912         }
1913         /*Flush any pending writes as we do double checked locking on class->properties */
1914         mono_memory_barrier ();
1915
1916         /* Leave this assignment as the last op in the function */
1917         class->events = events;
1918
1919         mono_loader_unlock ();
1920 }
1921
1922 /*
1923  * Global pool of interface IDs, represented as a bitset.
1924  * LOCKING: this is supposed to be accessed with the loader lock held.
1925  */
1926 static MonoBitSet *global_interface_bitset = NULL;
1927
1928 /*
1929  * mono_unload_interface_ids:
1930  * @bitset: bit set of interface IDs
1931  *
1932  * When an image is unloaded, the interface IDs associated with
1933  * the image are put back in the global pool of IDs so the numbers
1934  * can be reused.
1935  */
1936 void
1937 mono_unload_interface_ids (MonoBitSet *bitset)
1938 {
1939         mono_loader_lock ();
1940         mono_bitset_sub (global_interface_bitset, bitset);
1941         mono_loader_unlock ();
1942 }
1943
1944 /*
1945  * mono_get_unique_iid:
1946  * @class: interface
1947  *
1948  * Assign a unique integer ID to the interface represented by @class.
1949  * The ID will positive and as small as possible.
1950  * LOCKING: this is supposed to be called with the loader lock held.
1951  * Returns: the new ID.
1952  */
1953 static guint
1954 mono_get_unique_iid (MonoClass *class)
1955 {
1956         int iid;
1957
1958         g_assert (MONO_CLASS_IS_INTERFACE (class));
1959
1960         if (!global_interface_bitset) {
1961                 global_interface_bitset = mono_bitset_new (128, 0);
1962         }
1963
1964         iid = mono_bitset_find_first_unset (global_interface_bitset, -1);
1965         if (iid < 0) {
1966                 int old_size = mono_bitset_size (global_interface_bitset);
1967                 MonoBitSet *new_set = mono_bitset_clone (global_interface_bitset, old_size * 2);
1968                 mono_bitset_free (global_interface_bitset);
1969                 global_interface_bitset = new_set;
1970                 iid = old_size;
1971         }
1972         mono_bitset_set (global_interface_bitset, iid);
1973         /* set the bit also in the per-image set */
1974         if (class->image->interface_bitset) {
1975                 if (iid >= mono_bitset_size (class->image->interface_bitset)) {
1976                         MonoBitSet *new_set = mono_bitset_clone (class->image->interface_bitset, iid + 1);
1977                         mono_bitset_free (class->image->interface_bitset);
1978                         class->image->interface_bitset = new_set;
1979                 }
1980         } else {
1981                 class->image->interface_bitset = mono_bitset_new (iid + 1, 0);
1982         }
1983         mono_bitset_set (class->image->interface_bitset, iid);
1984
1985         if (mono_print_vtable) {
1986                 int generic_id;
1987                 char *type_name = mono_type_full_name (&class->byval_arg);
1988                 if (class->generic_class && !class->generic_class->context.class_inst->is_open) {
1989                         generic_id = class->generic_class->context.class_inst->id;
1990                         g_assert (generic_id != 0);
1991                 } else {
1992                         generic_id = 0;
1993                 }
1994                 printf ("Interface: assigned id %d to %s|%s|%d\n", iid, class->image->name, type_name, generic_id);
1995                 g_free (type_name);
1996         }
1997
1998         g_assert (iid <= 65535);
1999         return iid;
2000 }
2001
2002 static void
2003 collect_implemented_interfaces_aux (MonoClass *klass, GPtrArray **res)
2004 {
2005         int i;
2006         MonoClass *ic;
2007
2008         for (i = 0; i < klass->interface_count; i++) {
2009                 ic = klass->interfaces [i];
2010
2011                 if (*res == NULL)
2012                         *res = g_ptr_array_new ();
2013                 g_ptr_array_add (*res, ic);
2014                 mono_class_init (ic);
2015
2016                 collect_implemented_interfaces_aux (ic, res);
2017         }
2018 }
2019
2020 GPtrArray*
2021 mono_class_get_implemented_interfaces (MonoClass *klass)
2022 {
2023         GPtrArray *res = NULL;
2024
2025         collect_implemented_interfaces_aux (klass, &res);
2026         return res;
2027 }
2028
2029 static int
2030 compare_interface_ids (const void *p_key, const void *p_element) {
2031         const MonoClass *key = p_key;
2032         const MonoClass *element = *(MonoClass**) p_element;
2033
2034         return (key->interface_id - element->interface_id);
2035 }
2036
2037 int
2038 mono_class_interface_offset (MonoClass *klass, MonoClass *itf) {
2039         MonoClass **result = bsearch (
2040                         itf,
2041                         klass->interfaces_packed,
2042                         klass->interface_offsets_count,
2043                         sizeof (MonoClass *),
2044                         compare_interface_ids);
2045         if (result) {
2046                 return klass->interface_offsets_packed [result - (klass->interfaces_packed)];
2047         } else {
2048                 return -1;
2049         }
2050 }
2051
2052 static void
2053 print_implemented_interfaces (MonoClass *klass) {
2054         GPtrArray *ifaces = NULL;
2055         int i;
2056         int ancestor_level = 0;
2057
2058         printf ("Packed interface table for class %s has size %d\n", klass->name, klass->interface_offsets_count);
2059         for (i = 0; i < klass->interface_offsets_count; i++)
2060                 printf ("  [%03d][UUID %03d][SLOT %03d][SIZE  %03d] interface %s.%s\n", i,
2061                                 klass->interfaces_packed [i]->interface_id,
2062                                 klass->interface_offsets_packed [i],
2063                                 klass->interfaces_packed [i]->method.count,
2064                                 klass->interfaces_packed [i]->name_space,
2065                                 klass->interfaces_packed [i]->name );
2066         printf ("Interface flags: ");
2067         for (i = 0; i <= klass->max_interface_id; i++)
2068                 if (MONO_CLASS_IMPLEMENTS_INTERFACE (klass, i))
2069                         printf ("(%d,T)", i);
2070                 else
2071                         printf ("(%d,F)", i);
2072         printf ("\n");
2073         printf ("Dump interface flags:");
2074         for (i = 0; i < ((((klass->max_interface_id + 1) >> 3)) + (((klass->max_interface_id + 1) & 7)? 1 :0)); i++)
2075                 printf (" %02X", klass->interface_bitmap [i]);
2076         printf ("\n");
2077         while (klass != NULL) {
2078                 printf ("[LEVEL %d] Implemented interfaces by class %s:\n", ancestor_level, klass->name);
2079                 ifaces = mono_class_get_implemented_interfaces (klass);
2080                 if (ifaces) {
2081                         for (i = 0; i < ifaces->len; i++) {
2082                                 MonoClass *ic = g_ptr_array_index (ifaces, i);
2083                                 printf ("  [UIID %d] interface %s\n", ic->interface_id, ic->name);
2084                                 printf ("  [%03d][UUID %03d][SLOT %03d][SIZE  %03d] interface %s.%s\n", i,
2085                                                 ic->interface_id,
2086                                                 mono_class_interface_offset (klass, ic),
2087                                                 ic->method.count,
2088                                                 ic->name_space,
2089                                                 ic->name );
2090                         }
2091                         g_ptr_array_free (ifaces, TRUE);
2092                 }
2093                 ancestor_level ++;
2094                 klass = klass->parent;
2095         }
2096 }
2097
2098 static MonoClass*
2099 inflate_class_one_arg (MonoClass *gtype, MonoClass *arg0)
2100 {
2101         MonoType *args [1];
2102         args [0] = &arg0->byval_arg;
2103
2104         return mono_class_bind_generic_parameters (gtype, 1, args, FALSE);
2105 }
2106
2107 static MonoClass*
2108 array_class_get_if_rank (MonoClass *class, guint rank)
2109 {
2110         return rank ? mono_array_class_get (class, rank) :  class;
2111 }
2112
2113 static void
2114 fill_valuetype_array_derived_types (MonoClass **valuetype_types, MonoClass *eclass, int rank)
2115 {
2116         valuetype_types [0] = eclass;
2117         if (eclass == mono_defaults.int16_class)
2118                 valuetype_types [1] = mono_defaults.uint16_class;
2119         else if (eclass == mono_defaults.uint16_class)
2120                 valuetype_types [1] = mono_defaults.int16_class;
2121         else if (eclass == mono_defaults.int32_class)
2122                 valuetype_types [1] = mono_defaults.uint32_class;
2123         else if (eclass == mono_defaults.uint32_class)
2124                 valuetype_types [1] = mono_defaults.int32_class;
2125         else if (eclass == mono_defaults.int64_class)
2126                 valuetype_types [1] = mono_defaults.uint64_class;
2127         else if (eclass == mono_defaults.uint64_class)
2128                 valuetype_types [1] = mono_defaults.int64_class;
2129         else if (eclass == mono_defaults.byte_class)
2130                 valuetype_types [1] = mono_defaults.sbyte_class;
2131         else if (eclass == mono_defaults.sbyte_class)
2132                 valuetype_types [1] = mono_defaults.byte_class;
2133         else if (eclass->enumtype && eclass->enum_basetype)
2134                 valuetype_types [1] = mono_class_from_mono_type (eclass->enum_basetype);
2135 }
2136
2137 /* this won't be needed once bug #325495 is completely fixed
2138  * though we'll need something similar to know which interfaces to allow
2139  * in arrays when they'll be lazyly created
2140  *
2141  * FIXME: System.Array/InternalEnumerator don't need all this interface fabrication machinery.
2142  * MS returns diferrent types based on which instance is called. For example:
2143  *      object obj = new byte[10][];
2144  *      Type a = ((IEnumerable<byte[]>)obj).GetEnumerator ().GetType ();
2145  *      Type b = ((IEnumerable<IList<byte>>)obj).GetEnumerator ().GetType ();
2146  *      a != b ==> true
2147  *
2148  * Fixing this should kill quite some code, save some bits and improve compatbility.
2149  */
2150 static MonoClass**
2151 get_implicit_generic_array_interfaces (MonoClass *class, int *num, int *is_enumerator)
2152 {
2153         MonoClass *eclass = class->element_class;
2154         static MonoClass* generic_icollection_class = NULL;
2155         static MonoClass* generic_ienumerable_class = NULL;
2156         static MonoClass* generic_ienumerator_class = NULL;
2157         MonoClass *valuetype_types[2] = { NULL, NULL };
2158         MonoClass **interfaces = NULL;
2159         int i, interface_count, real_count, original_rank;
2160         int all_interfaces;
2161         gboolean internal_enumerator;
2162         gboolean eclass_is_valuetype;
2163
2164         if (!mono_defaults.generic_ilist_class) {
2165                 *num = 0;
2166                 return NULL;
2167         }
2168         internal_enumerator = FALSE;
2169         eclass_is_valuetype = FALSE;
2170         original_rank = eclass->rank;
2171         if (class->byval_arg.type != MONO_TYPE_SZARRAY) {
2172                 if (class->generic_class && class->nested_in == mono_defaults.array_class && strcmp (class->name, "InternalEnumerator`1") == 0)  {
2173                         /*
2174                          * For a Enumerator<T[]> we need to get the list of interfaces for T.
2175                          */
2176                         eclass = mono_class_from_mono_type (class->generic_class->context.class_inst->type_argv [0]);
2177                         original_rank = eclass->rank;
2178                         eclass = eclass->element_class;
2179                         internal_enumerator = TRUE;
2180                         *is_enumerator = TRUE;
2181                 } else {
2182                         *num = 0;
2183                         return NULL;
2184                 }
2185         }
2186
2187         /*
2188          * with this non-lazy impl we can't implement all the interfaces so we do just the minimal stuff
2189          * for deep levels of arrays of arrays (string[][] has all the interfaces, string[][][] doesn't)
2190          */
2191         all_interfaces = eclass->rank && eclass->element_class->rank? FALSE: TRUE;
2192
2193         if (!generic_icollection_class) {
2194                 generic_icollection_class = mono_class_from_name (mono_defaults.corlib,
2195                         "System.Collections.Generic", "ICollection`1");
2196                 generic_ienumerable_class = mono_class_from_name (mono_defaults.corlib,
2197                         "System.Collections.Generic", "IEnumerable`1");
2198                 generic_ienumerator_class = mono_class_from_name (mono_defaults.corlib,
2199                         "System.Collections.Generic", "IEnumerator`1");
2200         }
2201
2202         mono_class_init (eclass);
2203
2204         /*
2205          * Arrays in 2.0 need to implement a number of generic interfaces
2206          * (IList`1, ICollection`1, IEnumerable`1 for a number of types depending
2207          * on the element class). We collect the types needed to build the
2208          * instantiations in interfaces at intervals of 3, because 3 are
2209          * the generic interfaces needed to implement.
2210          */
2211         if (eclass->valuetype) {
2212                 fill_valuetype_array_derived_types (valuetype_types, eclass, original_rank);
2213
2214                 /* IList, ICollection, IEnumerable */
2215                 real_count = interface_count = valuetype_types [1] ? 6 : 3;
2216                 if (internal_enumerator) {
2217                         ++real_count;
2218                         if (valuetype_types [1])
2219                                 ++real_count;
2220                 }
2221
2222                 interfaces = g_malloc0 (sizeof (MonoClass*) * real_count);
2223                 interfaces [0] = valuetype_types [0];
2224                 if (valuetype_types [1])
2225                         interfaces [3] = valuetype_types [1];
2226
2227                 eclass_is_valuetype = TRUE;
2228         } else {
2229                 int j;
2230                 int idepth = eclass->idepth;
2231                 if (!internal_enumerator)
2232                         idepth--;
2233                 interface_count = all_interfaces? eclass->interface_offsets_count: eclass->interface_count;
2234                 /* we add object for interfaces and the supertypes for the other
2235                  * types. The last of the supertypes is the element class itself which we
2236                  * already created the explicit interfaces for (so we include it for IEnumerator
2237                  * and exclude it for arrays).
2238                  */
2239                 if (MONO_CLASS_IS_INTERFACE (eclass))
2240                         interface_count++;
2241                 else
2242                         interface_count += idepth;
2243                 if (eclass->rank && eclass->element_class->valuetype) {
2244                         fill_valuetype_array_derived_types (valuetype_types, eclass->element_class, original_rank);
2245                         if (valuetype_types [1])
2246                                 ++interface_count;
2247                 }
2248                 /* IList, ICollection, IEnumerable */
2249                 interface_count *= 3;
2250                 real_count = interface_count;
2251                 if (internal_enumerator) {
2252                         real_count += (MONO_CLASS_IS_INTERFACE (eclass) ? 1 : idepth) + eclass->interface_offsets_count;
2253                         if (valuetype_types [1])
2254                                 ++real_count;
2255                 }
2256                 interfaces = g_malloc0 (sizeof (MonoClass*) * real_count);
2257                 if (MONO_CLASS_IS_INTERFACE (eclass)) {
2258                         interfaces [0] = mono_defaults.object_class;
2259                         j = 3;
2260                 } else {
2261                         j = 0;
2262                         for (i = 0; i < idepth; i++) {
2263                                 mono_class_init (eclass->supertypes [i]);
2264                                 interfaces [j] = eclass->supertypes [i];
2265                                 j += 3;
2266                         }
2267                 }
2268                 if (all_interfaces) {
2269                         for (i = 0; i < eclass->interface_offsets_count; i++) {
2270                                 interfaces [j] = eclass->interfaces_packed [i];
2271                                 j += 3;
2272                         }
2273                 } else {
2274                         for (i = 0; i < eclass->interface_count; i++) {
2275                                 interfaces [j] = eclass->interfaces [i];
2276                                 j += 3;
2277                         }
2278                 }
2279                 if (valuetype_types [1]) {
2280                         interfaces [j] = array_class_get_if_rank (valuetype_types [1], original_rank);
2281                         j += 3;
2282                 }
2283         }
2284
2285         /* instantiate the generic interfaces */
2286         for (i = 0; i < interface_count; i += 3) {
2287                 MonoClass *iface = interfaces [i];
2288
2289                 interfaces [i + 0] = inflate_class_one_arg (mono_defaults.generic_ilist_class, iface);
2290                 interfaces [i + 1] = inflate_class_one_arg (generic_icollection_class, iface);
2291                 interfaces [i + 2] = inflate_class_one_arg (generic_ienumerable_class, iface);
2292         }
2293         if (internal_enumerator) {
2294                 int j;
2295                 /* instantiate IEnumerator<iface> */
2296                 for (i = 0; i < interface_count; i++) {
2297                         interfaces [i] = inflate_class_one_arg (generic_ienumerator_class, interfaces [i]);
2298                 }
2299                 j = interface_count;
2300                 if (!eclass_is_valuetype) {
2301                         if (MONO_CLASS_IS_INTERFACE (eclass)) {
2302                                 interfaces [j] = inflate_class_one_arg (generic_ienumerator_class, mono_defaults.object_class);
2303                                 j ++;
2304                         } else {
2305                                 for (i = 0; i < eclass->idepth; i++) {
2306                                         interfaces [j] = inflate_class_one_arg (generic_ienumerator_class, eclass->supertypes [i]);
2307                                         j ++;
2308                                 }
2309                         }
2310                         for (i = 0; i < eclass->interface_offsets_count; i++) {
2311                                 interfaces [j] = inflate_class_one_arg (generic_ienumerator_class, eclass->interfaces_packed [i]);
2312                                 j ++;
2313                         }
2314                 } else {
2315                         interfaces [j++] = inflate_class_one_arg (generic_ienumerator_class, array_class_get_if_rank (valuetype_types [0], original_rank));
2316                 }
2317                 if (valuetype_types [1])
2318                         interfaces [j] = inflate_class_one_arg (generic_ienumerator_class, array_class_get_if_rank (valuetype_types [1], original_rank));
2319         }
2320 #if 0
2321         {
2322         char *type_name = mono_type_get_name_full (&class->byval_arg, 0);
2323         for (i = 0; i  < real_count; ++i) {
2324                 char *name = mono_type_get_name_full (&interfaces [i]->byval_arg, 0);
2325                 g_print ("%s implements %s\n", type_name, name);
2326                 g_free (name);
2327         }
2328         g_free (type_name);
2329         }
2330 #endif
2331         *num = real_count;
2332         return interfaces;
2333 }
2334
2335 static int
2336 find_array_interface (MonoClass *klass, const char *name)
2337 {
2338         int i;
2339         for (i = 0; i < klass->interface_count; ++i) {
2340                 if (strcmp (klass->interfaces [i]->name, name) == 0)
2341                         return i;
2342         }
2343         return -1;
2344 }
2345
2346 /*
2347  * LOCKING: this is supposed to be called with the loader lock held.
2348  */
2349 static int
2350 setup_interface_offsets (MonoClass *class, int cur_slot)
2351 {
2352         MonoClass *k, *ic;
2353         int i, max_iid;
2354         MonoClass **interfaces_full;
2355         int *interface_offsets_full;
2356         GPtrArray *ifaces;
2357         int interface_offsets_count;
2358         MonoClass **array_interfaces;
2359         int num_array_interfaces;
2360         int is_enumerator = FALSE;
2361
2362         /*
2363          * get the implicit generic interfaces for either the arrays or for System.Array/InternalEnumerator<T>
2364          * implicit interfaces have the property that they are assigned the same slot in the
2365          * vtables for compatible interfaces
2366          */
2367         array_interfaces = get_implicit_generic_array_interfaces (class, &num_array_interfaces, &is_enumerator);
2368
2369         /* compute maximum number of slots and maximum interface id */
2370         max_iid = 0;
2371         for (k = class; k ; k = k->parent) {
2372                 for (i = 0; i < k->interface_count; i++) {
2373                         ic = k->interfaces [i];
2374
2375                         if (!ic->inited)
2376                                 mono_class_init (ic);
2377
2378                         if (max_iid < ic->interface_id)
2379                                 max_iid = ic->interface_id;
2380                 }
2381                 ifaces = mono_class_get_implemented_interfaces (k);
2382                 if (ifaces) {
2383                         for (i = 0; i < ifaces->len; ++i) {
2384                                 ic = g_ptr_array_index (ifaces, i);
2385                                 if (max_iid < ic->interface_id)
2386                                         max_iid = ic->interface_id;
2387                         }
2388                         g_ptr_array_free (ifaces, TRUE);
2389                 }
2390         }
2391         for (i = 0; i < num_array_interfaces; ++i) {
2392                 ic = array_interfaces [i];
2393                 mono_class_init (ic);
2394                 if (max_iid < ic->interface_id)
2395                         max_iid = ic->interface_id;
2396         }
2397
2398         if (MONO_CLASS_IS_INTERFACE (class)) {
2399                 if (max_iid < class->interface_id)
2400                         max_iid = class->interface_id;
2401         }
2402         class->max_interface_id = max_iid;
2403         /* compute vtable offset for interfaces */
2404         interfaces_full = g_malloc (sizeof (MonoClass*) * (max_iid + 1));
2405         interface_offsets_full = g_malloc (sizeof (int) * (max_iid + 1));
2406
2407         for (i = 0; i <= max_iid; i++) {
2408                 interfaces_full [i] = NULL;
2409                 interface_offsets_full [i] = -1;
2410         }
2411
2412         ifaces = mono_class_get_implemented_interfaces (class);
2413         if (ifaces) {
2414                 for (i = 0; i < ifaces->len; ++i) {
2415                         ic = g_ptr_array_index (ifaces, i);
2416                         interfaces_full [ic->interface_id] = ic;
2417                         interface_offsets_full [ic->interface_id] = cur_slot;
2418                         cur_slot += ic->method.count;
2419                 }
2420                 g_ptr_array_free (ifaces, TRUE);
2421         }
2422
2423         for (k = class->parent; k ; k = k->parent) {
2424                 ifaces = mono_class_get_implemented_interfaces (k);
2425                 if (ifaces) {
2426                         for (i = 0; i < ifaces->len; ++i) {
2427                                 ic = g_ptr_array_index (ifaces, i);
2428
2429                                 if (interface_offsets_full [ic->interface_id] == -1) {
2430                                         int io = mono_class_interface_offset (k, ic);
2431
2432                                         g_assert (io >= 0);
2433
2434                                         interfaces_full [ic->interface_id] = ic;
2435                                         interface_offsets_full [ic->interface_id] = io;
2436                                 }
2437                         }
2438                         g_ptr_array_free (ifaces, TRUE);
2439                 }
2440         }
2441
2442         if (MONO_CLASS_IS_INTERFACE (class)) {
2443                 interfaces_full [class->interface_id] = class;
2444                 interface_offsets_full [class->interface_id] = cur_slot;
2445         }
2446
2447         if (num_array_interfaces) {
2448                 if (is_enumerator) {
2449                         int ienumerator_offset;
2450                         int ienumerator_idx = find_array_interface (class, "IEnumerator`1");
2451                         ienumerator_offset = interface_offsets_full [class->interfaces [ienumerator_idx]->interface_id];
2452                         for (i = 0; i < num_array_interfaces; ++i) {
2453                                 ic = array_interfaces [i];
2454                                 interfaces_full [ic->interface_id] = ic;
2455                                 if (strcmp (ic->name, "IEnumerator`1") == 0)
2456                                         interface_offsets_full [ic->interface_id] = ienumerator_offset;
2457                                 else
2458                                         g_assert_not_reached ();
2459                                 /*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);*/
2460                         }
2461                 } else {
2462                         int ilist_offset, icollection_offset, ienumerable_offset;
2463                         int ilist_iface_idx = find_array_interface (class, "IList`1");
2464                         int icollection_iface_idx = find_array_interface (class->interfaces [ilist_iface_idx], "ICollection`1");
2465                         int ienumerable_iface_idx = find_array_interface (class->interfaces [ilist_iface_idx], "IEnumerable`1");
2466                         ilist_offset = interface_offsets_full [class->interfaces [ilist_iface_idx]->interface_id];
2467                         icollection_offset = interface_offsets_full [class->interfaces [ilist_iface_idx]->interfaces [icollection_iface_idx]->interface_id];
2468                         ienumerable_offset = interface_offsets_full [class->interfaces [ilist_iface_idx]->interfaces [ienumerable_iface_idx]->interface_id];
2469                         g_assert (ilist_offset >= 0 && icollection_offset >= 0 && ienumerable_offset >= 0);
2470                         for (i = 0; i < num_array_interfaces; ++i) {
2471                                 ic = array_interfaces [i];
2472                                 interfaces_full [ic->interface_id] = ic;
2473                                 if (ic->generic_class->container_class == mono_defaults.generic_ilist_class)
2474                                         interface_offsets_full [ic->interface_id] = ilist_offset;
2475                                 else if (strcmp (ic->name, "ICollection`1") == 0)
2476                                         interface_offsets_full [ic->interface_id] = icollection_offset;
2477                                 else if (strcmp (ic->name, "IEnumerable`1") == 0)
2478                                         interface_offsets_full [ic->interface_id] = ienumerable_offset;
2479                                 else
2480                                         g_assert_not_reached ();
2481                                 /*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);*/
2482                         }
2483                 }
2484         }
2485
2486         for (interface_offsets_count = 0, i = 0; i <= max_iid; i++) {
2487                 if (interface_offsets_full [i] != -1) {
2488                         interface_offsets_count ++;
2489                 }
2490         }
2491
2492         /*
2493          * We might get called twice: once from mono_class_init () then once from
2494          * mono_class_setup_vtable ().
2495          */
2496         if (class->interfaces_packed) {
2497                 g_assert (class->interface_offsets_count == interface_offsets_count);
2498         } else {
2499                 class->interface_offsets_count = interface_offsets_count;
2500                 class->interfaces_packed = mono_image_alloc (class->image, sizeof (MonoClass*) * interface_offsets_count);
2501                 class->interface_offsets_packed = mono_image_alloc (class->image, sizeof (guint16) * interface_offsets_count);
2502                 class->interface_bitmap = mono_image_alloc0 (class->image, (sizeof (guint8) * ((max_iid + 1) >> 3)) + (((max_iid + 1) & 7)? 1 :0));
2503                 for (interface_offsets_count = 0, i = 0; i <= max_iid; i++) {
2504                         if (interface_offsets_full [i] != -1) {
2505                                 class->interface_bitmap [i >> 3] |= (1 << (i & 7));
2506                                 class->interfaces_packed [interface_offsets_count] = interfaces_full [i];
2507                                 class->interface_offsets_packed [interface_offsets_count] = interface_offsets_full [i];
2508                                 /*if (num_array_interfaces)
2509                                   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]);*/
2510                                 interface_offsets_count ++;
2511                         }
2512                 }
2513         }
2514
2515         g_free (interfaces_full);
2516         g_free (interface_offsets_full);
2517         g_free (array_interfaces);
2518
2519         //printf ("JUST DONE: ");
2520         //print_implemented_interfaces (class);
2521
2522         return cur_slot;
2523 }
2524
2525 /*
2526  * Setup interface offsets for interfaces. Used by Ref.Emit.
2527  */
2528 void
2529 mono_class_setup_interface_offsets (MonoClass *class)
2530 {
2531         mono_loader_lock ();
2532
2533         setup_interface_offsets (class, 0);
2534
2535         mono_loader_unlock ();
2536 }
2537
2538 /*
2539  * mono_class_setup_vtable:
2540  *
2541  *   Creates the generic vtable of CLASS.
2542  * Initializes the following fields in MonoClass:
2543  * - vtable
2544  * - vtable_size
2545  * Plus all the fields initialized by setup_interface_offsets ().
2546  * If there is an error during vtable construction, class->exception_type is set.
2547  *
2548  * LOCKING: Acquires the loader lock.
2549  */
2550 void
2551 mono_class_setup_vtable (MonoClass *class)
2552 {
2553         MonoMethod **overrides;
2554         MonoGenericContext *context;
2555         guint32 type_token;
2556         int onum = 0;
2557         int i;
2558         gboolean ok = TRUE;
2559
2560         if (class->vtable)
2561                 return;
2562
2563         if (mono_debug_using_mono_debugger ())
2564                 /* The debugger currently depends on this */
2565                 mono_class_setup_methods (class);
2566
2567         if (MONO_CLASS_IS_INTERFACE (class)) {
2568                 /* This sets method->slot for all methods if this is an interface */
2569                 mono_class_setup_methods (class);
2570                 return;
2571         }
2572
2573         mono_loader_lock ();
2574
2575         if (class->vtable) {
2576                 mono_loader_unlock ();
2577                 return;
2578         }
2579
2580         mono_stats.generic_vtable_count ++;
2581
2582         if (class->generic_class) {
2583                 context = mono_class_get_context (class);
2584                 type_token = class->generic_class->container_class->type_token;
2585         } else {
2586                 context = (MonoGenericContext *) class->generic_container;
2587                 type_token = class->type_token;
2588         }
2589
2590         if (class->image->dynamic) {
2591                 if (class->generic_class) {
2592                         MonoClass *gklass = class->generic_class->container_class;
2593
2594                         mono_reflection_get_dynamic_overrides (gklass, &overrides, &onum);
2595                         for (i = 0; i < onum; ++i) {
2596                                 MonoMethod *override = overrides [(i * 2) + 1];
2597                                 MonoMethod *inflated = NULL;
2598                                 int j;
2599
2600                                 for (j = 0; j < class->method.count; ++j) {
2601                                         if (gklass->methods [j] == override) {
2602                                                 inflated = class->methods [j];
2603                                                 break;
2604                                         }
2605                                 }
2606                                 g_assert (inflated);
2607
2608                                 overrides [(i * 2) + 1] = inflated;
2609                         }
2610                 } else {
2611                         mono_reflection_get_dynamic_overrides (class, &overrides, &onum);
2612                 }
2613         } else {
2614                 /* The following call fails if there are missing methods in the type */
2615                 ok = mono_class_get_overrides_full (class->image, type_token, &overrides, &onum, context);
2616         }
2617
2618         if (ok)
2619                 mono_class_setup_vtable_general (class, overrides, onum);
2620
2621         g_free (overrides);
2622
2623         mono_loader_unlock ();
2624
2625         return;
2626 }
2627
2628 static void
2629 check_core_clr_override_method (MonoClass *class, MonoMethod *override, MonoMethod *base)
2630 {
2631         MonoSecurityCoreCLRLevel override_level = mono_security_core_clr_method_level (override, FALSE);
2632         MonoSecurityCoreCLRLevel base_level = mono_security_core_clr_method_level (base, FALSE);
2633
2634         if (override_level != base_level && base_level == MONO_SECURITY_CORE_CLR_CRITICAL)
2635                 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL);
2636 }
2637
2638
2639 #define DEBUG_INTERFACE_VTABLE_CODE 0
2640 #define TRACE_INTERFACE_VTABLE_CODE 0
2641 #define VERIFY_INTERFACE_VTABLE_CODE 0
2642
2643 #if (TRACE_INTERFACE_VTABLE_CODE|DEBUG_INTERFACE_VTABLE_CODE)
2644 #define DEBUG_INTERFACE_VTABLE(stmt) do {\
2645         stmt;\
2646 } while (0)
2647 #else
2648 #define DEBUG_INTERFACE_VTABLE(stmt)
2649 #endif
2650
2651 #if TRACE_INTERFACE_VTABLE_CODE
2652 #define TRACE_INTERFACE_VTABLE(stmt) do {\
2653         stmt;\
2654 } while (0)
2655 #else
2656 #define TRACE_INTERFACE_VTABLE(stmt)
2657 #endif
2658
2659 #if VERIFY_INTERFACE_VTABLE_CODE
2660 #define VERIFY_INTERFACE_VTABLE(stmt) do {\
2661         stmt;\
2662 } while (0)
2663 #else
2664 #define VERIFY_INTERFACE_VTABLE(stmt)
2665 #endif
2666
2667
2668 #if (TRACE_INTERFACE_VTABLE_CODE|DEBUG_INTERFACE_VTABLE_CODE)
2669 static char*
2670 mono_signature_get_full_desc (MonoMethodSignature *sig, gboolean include_namespace)
2671 {
2672         int i;
2673         char *result;
2674         GString *res = g_string_new ("");
2675
2676         g_string_append_c (res, '(');
2677         for (i = 0; i < sig->param_count; ++i) {
2678                 if (i > 0)
2679                         g_string_append_c (res, ',');
2680                 mono_type_get_desc (res, sig->params [i], include_namespace);
2681         }
2682         g_string_append (res, ")=>");
2683         if (sig->ret != NULL) {
2684                 mono_type_get_desc (res, sig->ret, include_namespace);
2685         } else {
2686                 g_string_append (res, "NULL");
2687         }
2688         result = res->str;
2689         g_string_free (res, FALSE);
2690         return result;
2691 }
2692 static void
2693 print_method_signatures (MonoMethod *im, MonoMethod *cm) {
2694         char *im_sig = mono_signature_get_full_desc (mono_method_signature (im), TRUE);
2695         char *cm_sig = mono_signature_get_full_desc (mono_method_signature (cm), TRUE);
2696         printf ("(IM \"%s\", CM \"%s\")", im_sig, cm_sig);
2697         g_free (im_sig);
2698         g_free (cm_sig);
2699
2700 }
2701
2702 #endif
2703 static gboolean
2704 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) {
2705         if (strcmp (im->name, cm->name) == 0) {
2706                 if (! (cm->flags & METHOD_ATTRIBUTE_PUBLIC)) {
2707                         TRACE_INTERFACE_VTABLE (printf ("[PUBLIC CHECK FAILED]"));
2708                         return FALSE;
2709                 }
2710                 if (! slot_is_empty) {
2711                         if (require_newslot) {
2712                                 if (! interface_is_explicitly_implemented_by_class) {
2713                                         TRACE_INTERFACE_VTABLE (printf ("[NOT EXPLICIT IMPLEMENTATION IN FULL SLOT REFUSED]"));
2714                                         return FALSE;
2715                                 }
2716                                 if (! (cm->flags & METHOD_ATTRIBUTE_NEW_SLOT)) {
2717                                         TRACE_INTERFACE_VTABLE (printf ("[NEWSLOT CHECK FAILED]"));
2718                                         return FALSE;
2719                                 }
2720                         } else {
2721                                 TRACE_INTERFACE_VTABLE (printf ("[FULL SLOT REFUSED]"));
2722                         }
2723                 }
2724                 if (! mono_metadata_signature_equal (mono_method_signature (cm), mono_method_signature (im))) {
2725                         TRACE_INTERFACE_VTABLE (printf ("[SIGNATURE CHECK FAILED  "));
2726                         TRACE_INTERFACE_VTABLE (print_method_signatures (im, cm));
2727                         TRACE_INTERFACE_VTABLE (printf ("]"));
2728                         return FALSE;
2729                 }
2730                 TRACE_INTERFACE_VTABLE (printf ("[SECURITY CHECKS]"));
2731                 /* CAS - SecurityAction.InheritanceDemand on interface */
2732                 if (security_enabled && (im->flags & METHOD_ATTRIBUTE_HAS_SECURITY)) {
2733                         mono_secman_inheritancedemand_method (cm, im);
2734                 }
2735
2736                 if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
2737                         check_core_clr_override_method (class, cm, im);
2738                 TRACE_INTERFACE_VTABLE (printf ("[NAME CHECK OK]"));
2739                 return TRUE;
2740         } else {
2741                 MonoClass *ic = im->klass;
2742                 const char *ic_name_space = ic->name_space;
2743                 const char *ic_name = ic->name;
2744                 char *subname;
2745
2746                 if (! require_newslot) {
2747                         TRACE_INTERFACE_VTABLE (printf ("[INJECTED METHOD REFUSED]"));
2748                         return FALSE;
2749                 }
2750                 if (cm->klass->rank == 0) {
2751                         TRACE_INTERFACE_VTABLE (printf ("[RANK CHECK FAILED]"));
2752                         return FALSE;
2753                 }
2754                 if (! mono_metadata_signature_equal (mono_method_signature (cm), mono_method_signature (im))) {
2755                         TRACE_INTERFACE_VTABLE (printf ("[(INJECTED) SIGNATURE CHECK FAILED  "));
2756                         TRACE_INTERFACE_VTABLE (print_method_signatures (im, cm));
2757                         TRACE_INTERFACE_VTABLE (printf ("]"));
2758                         return FALSE;
2759                 }
2760                 if (mono_class_get_image (ic) != mono_defaults.corlib) {
2761                         TRACE_INTERFACE_VTABLE (printf ("[INTERFACE CORLIB CHECK FAILED]"));
2762                         return FALSE;
2763                 }
2764                 if ((ic_name_space == NULL) || (strcmp (ic_name_space, "System.Collections.Generic") != 0)) {
2765                         TRACE_INTERFACE_VTABLE (printf ("[INTERFACE NAMESPACE CHECK FAILED]"));
2766                         return FALSE;
2767                 }
2768                 if ((ic_name == NULL) || ((strcmp (ic_name, "IEnumerable`1") != 0) && (strcmp (ic_name, "ICollection`1") != 0) && (strcmp (ic_name, "IList`1") != 0))) {
2769                         TRACE_INTERFACE_VTABLE (printf ("[INTERFACE NAME CHECK FAILED]"));
2770                         return FALSE;
2771                 }
2772
2773                 subname = strstr (cm->name, ic_name_space);
2774                 if (subname != cm->name) {
2775                         TRACE_INTERFACE_VTABLE (printf ("[ACTUAL NAMESPACE CHECK FAILED]"));
2776                         return FALSE;
2777                 }
2778                 subname += strlen (ic_name_space);
2779                 if (subname [0] != '.') {
2780                         TRACE_INTERFACE_VTABLE (printf ("[FIRST DOT CHECK FAILED]"));
2781                         return FALSE;
2782                 }
2783                 subname ++;
2784                 if (strstr (subname, ic_name) != subname) {
2785                         TRACE_INTERFACE_VTABLE (printf ("[ACTUAL CLASS NAME CHECK FAILED]"));
2786                         return FALSE;
2787                 }
2788                 subname += strlen (ic_name);
2789                 if (subname [0] != '.') {
2790                         TRACE_INTERFACE_VTABLE (printf ("[SECOND DOT CHECK FAILED]"));
2791                         return FALSE;
2792                 }
2793                 subname ++;
2794                 if (strcmp (subname, im->name) != 0) {
2795                         TRACE_INTERFACE_VTABLE (printf ("[METHOD NAME CHECK FAILED]"));
2796                         return FALSE;
2797                 }
2798
2799                 TRACE_INTERFACE_VTABLE (printf ("[SECURITY CHECKS (INJECTED CASE)]"));
2800                 /* CAS - SecurityAction.InheritanceDemand on interface */
2801                 if (security_enabled && (im->flags & METHOD_ATTRIBUTE_HAS_SECURITY)) {
2802                         mono_secman_inheritancedemand_method (cm, im);
2803                 }
2804
2805                 if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
2806                         check_core_clr_override_method (class, cm, im);
2807
2808                 TRACE_INTERFACE_VTABLE (printf ("[INJECTED INTERFACE CHECK OK]"));
2809                 return TRUE;
2810         }
2811 }
2812
2813 #if (TRACE_INTERFACE_VTABLE_CODE|DEBUG_INTERFACE_VTABLE_CODE)
2814 static void
2815 foreach_override (gpointer key, gpointer value, gpointer user_data) {
2816         MonoMethod *method = key;
2817         MonoMethod *override = value;
2818         MonoClass *method_class = mono_method_get_class (method);
2819         MonoClass *override_class = mono_method_get_class (override);
2820
2821         printf ("  Method '%s.%s:%s' has override '%s.%s:%s'\n",
2822                         mono_class_get_namespace (method_class), mono_class_get_name (method_class), mono_method_get_name (method),
2823                         mono_class_get_namespace (override_class), mono_class_get_name (override_class), mono_method_get_name (override));
2824 }
2825 static void
2826 print_overrides (GHashTable *override_map, const char *message) {
2827         if (override_map) {
2828                 printf ("Override map \"%s\" START:\n", message);
2829                 g_hash_table_foreach (override_map, foreach_override, NULL);
2830                 printf ("Override map \"%s\" END.\n", message);
2831         } else {
2832                 printf ("Override map \"%s\" EMPTY.\n", message);
2833         }
2834 }
2835 static void
2836 print_vtable_full (MonoClass *class, MonoMethod** vtable, int size, int first_non_interface_slot, const char *message, gboolean print_interfaces) {
2837         char *full_name = mono_type_full_name (&class->byval_arg);
2838         int i;
2839         int parent_size;
2840
2841         printf ("*** Vtable for class '%s' at \"%s\" (size %d)\n", full_name, message, size);
2842
2843         if (print_interfaces) {
2844                 print_implemented_interfaces (class);
2845                 printf ("* Interfaces for class '%s' done.\nStarting vtable (size %d):\n", full_name, size);
2846         }
2847
2848         if (class->parent) {
2849                 parent_size = class->parent->vtable_size;
2850         } else {
2851                 parent_size = 0;
2852         }
2853         for (i = 0; i < size; ++i) {
2854                 MonoMethod *cm = vtable [i];
2855                 if (cm) {
2856                         char *cm_name = mono_method_full_name (cm, TRUE);
2857                         char newness = (i < parent_size) ? 'O' : ((i < first_non_interface_slot) ? 'I' : 'N');
2858                         printf ("  [%c][%03d][INDEX %03d] %s\n", newness, i, cm->slot, cm_name);
2859                         g_free (cm_name);
2860                 }
2861         }
2862
2863         g_free (full_name);
2864 }
2865 #endif
2866
2867 #if VERIFY_INTERFACE_VTABLE_CODE
2868 static int
2869 mono_method_try_get_vtable_index (MonoMethod *method)
2870 {
2871         if (method->is_inflated && (method->flags & METHOD_ATTRIBUTE_VIRTUAL)) {
2872                 MonoMethodInflated *imethod = (MonoMethodInflated*)method;
2873                 if (imethod->declaring->is_generic)
2874                         return imethod->declaring->slot;
2875         }
2876         return method->slot;
2877 }
2878
2879 static void
2880 mono_class_verify_vtable (MonoClass *class)
2881 {
2882         int i;
2883         char *full_name = mono_type_full_name (&class->byval_arg);
2884
2885         printf ("*** Verifying VTable of class '%s' \n", full_name);
2886         g_free (full_name);
2887         full_name = NULL;
2888
2889         if (!class->methods)
2890                 return;
2891
2892         for (i = 0; i < class->method.count; ++i) {
2893                 MonoMethod *cm = class->methods [i];
2894                 int slot;
2895
2896                 if (!(cm->flags & METHOD_ATTRIBUTE_VIRTUAL))
2897                         continue;
2898
2899                 g_free (full_name);
2900                 full_name = mono_method_full_name (cm, TRUE);
2901
2902                 slot = mono_method_try_get_vtable_index (cm);
2903                 if (slot >= 0) {
2904                         if (slot >= class->vtable_size) {
2905                                 printf ("\tInvalid method %s at index %d with vtable of length %d\n", full_name, slot, class->vtable_size);
2906                                 continue;
2907                         }
2908
2909                         if (slot >= 0 && class->vtable [slot] != cm && (class->vtable [slot] && class->vtable [slot]->wrapper_type != MONO_WRAPPER_STATIC_RGCTX_INVOKE)) {
2910                                 char *other_name = class->vtable [slot] ? mono_method_full_name (class->vtable [slot], TRUE) : g_strdup ("[null value]");
2911                                 printf ("\tMethod %s has slot %d but vtable has %s on it\n", full_name, slot, other_name);
2912                                 g_free (other_name);
2913                         }
2914                 } else
2915                         printf ("\tVirtual method %s does n't have an assigned slot\n", full_name);
2916         }
2917         g_free (full_name);
2918 }
2919 #endif
2920
2921 static void
2922 print_unimplemented_interface_method_info (MonoClass *class, MonoClass *ic, MonoMethod *im, int im_slot, MonoMethod **overrides, int onum) {
2923         int index;
2924         char *method_signature;
2925
2926         for (index = 0; index < onum; ++index) {
2927                 g_print (" at slot %d: %s (%d) overrides %s (%d)\n", im_slot, overrides [index*2+1]->name,
2928                          overrides [index*2+1]->slot, overrides [index*2]->name, overrides [index*2]->slot);
2929         }
2930         method_signature = mono_signature_get_desc (mono_method_signature (im), FALSE);
2931         printf ("no implementation for interface method %s::%s(%s) in class %s.%s\n",
2932                 mono_type_get_name (&ic->byval_arg), im->name, method_signature, class->name_space, class->name);
2933         g_free (method_signature);
2934         mono_class_setup_methods (class);
2935         for (index = 0; index < class->method.count; ++index) {
2936                 MonoMethod *cm = class->methods [index];
2937                 method_signature = mono_signature_get_desc (mono_method_signature (cm), TRUE);
2938
2939                 printf ("METHOD %s(%s)\n", cm->name, method_signature);
2940                 g_free (method_signature);
2941         }
2942 }
2943
2944 /*
2945  * LOCKING: this is supposed to be called with the loader lock held.
2946  */
2947 void
2948 mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int onum)
2949 {
2950         MonoClass *k, *ic;
2951         MonoMethod **vtable;
2952         int i, max_vtsize = 0, max_iid, cur_slot = 0;
2953         GPtrArray *ifaces = NULL;
2954         GHashTable *override_map = NULL;
2955         gboolean security_enabled = mono_is_security_manager_active ();
2956         MonoMethod *cm;
2957         gpointer class_iter;
2958 #if (DEBUG_INTERFACE_VTABLE_CODE|TRACE_INTERFACE_VTABLE_CODE)
2959         int first_non_interface_slot;
2960 #endif
2961
2962         if (class->vtable)
2963                 return;
2964
2965         ifaces = mono_class_get_implemented_interfaces (class);
2966         if (ifaces) {
2967                 for (i = 0; i < ifaces->len; i++) {
2968                         MonoClass *ic = g_ptr_array_index (ifaces, i);
2969                         max_vtsize += ic->method.count;
2970                 }
2971                 g_ptr_array_free (ifaces, TRUE);
2972                 ifaces = NULL;
2973         }
2974
2975         if (class->parent) {
2976                 mono_class_init (class->parent);
2977                 mono_class_setup_vtable (class->parent);
2978                 max_vtsize += class->parent->vtable_size;
2979                 cur_slot = class->parent->vtable_size;
2980         }
2981
2982         max_vtsize += class->method.count;
2983
2984         vtable = alloca (sizeof (gpointer) * max_vtsize);
2985         memset (vtable, 0, sizeof (gpointer) * max_vtsize);
2986
2987         /* printf ("METAINIT %s.%s\n", class->name_space, class->name); */
2988
2989         cur_slot = setup_interface_offsets (class, cur_slot);
2990         max_iid = class->max_interface_id;
2991         DEBUG_INTERFACE_VTABLE (first_non_interface_slot = cur_slot);
2992
2993         /* Optimized version for generic instances */
2994         if (class->generic_class) {
2995                 MonoClass *gklass = class->generic_class->container_class;
2996                 gboolean usable = TRUE;
2997
2998                 mono_class_setup_vtable (gklass);
2999                 for (i = 0; i < gklass->vtable_size; ++i)
3000                         if (gklass->vtable [i] && gklass->vtable [i]->wrapper_type == MONO_WRAPPER_STATIC_RGCTX_INVOKE)
3001                                 usable = FALSE;
3002
3003                 if (usable) {
3004                         MonoMethod **tmp = mono_image_alloc0 (class->image, sizeof (gpointer) * gklass->vtable_size);
3005                         class->vtable_size = gklass->vtable_size;
3006                         for (i = 0; i < gklass->vtable_size; ++i)
3007                                 if (gklass->vtable [i])
3008                                         tmp [i] = mono_class_inflate_generic_method_full (gklass->vtable [i], class, mono_class_get_context (class));
3009                         mono_memory_barrier ();
3010                         class->vtable = tmp;
3011
3012                         /* Have to set method->slot for abstract virtual methods */
3013                         if (class->methods && gklass->methods) {
3014                                 for (i = 0; i < class->method.count; ++i)
3015                                         if (class->methods [i]->slot == -1)
3016                                                 class->methods [i]->slot = gklass->methods [i]->slot;
3017                         }
3018
3019                         return;
3020                 }
3021         }
3022
3023         if (class->parent && class->parent->vtable_size) {
3024                 MonoClass *parent = class->parent;
3025                 int i;
3026
3027                 memcpy (vtable, parent->vtable,  sizeof (gpointer) * parent->vtable_size);
3028
3029                 // Also inherit parent interface vtables, just as a starting point.
3030                 // This is needed otherwise bug-77127.exe fails when the property methods
3031                 // have different names in the iterface and the class, because for child
3032                 // classes the ".override" information is not used anymore.
3033                 for (i = 0; i < parent->interface_offsets_count; i++) {
3034                         MonoClass *parent_interface = parent->interfaces_packed [i];
3035                         int interface_offset = mono_class_interface_offset (class, parent_interface);
3036
3037                         if (interface_offset >= parent->vtable_size) {
3038                                 int parent_interface_offset = mono_class_interface_offset (parent, parent_interface);
3039                                 int j;
3040
3041                                 mono_class_setup_methods (parent_interface);
3042                                 TRACE_INTERFACE_VTABLE (printf ("    +++ Inheriting interface %s.%s\n", parent_interface->name_space, parent_interface->name));
3043                                 for (j = 0; j < parent_interface->method.count; j++) {
3044                                         vtable [interface_offset + j] = parent->vtable [parent_interface_offset + j];
3045                                         TRACE_INTERFACE_VTABLE (printf ("    --- Inheriting: [%03d][(%03d)+(%03d)] => [%03d][(%03d)+(%03d)]\n",
3046                                                         parent_interface_offset + j, parent_interface_offset, j,
3047                                                         interface_offset + j, interface_offset, j));
3048                                 }
3049                         }
3050
3051                 }
3052         }
3053
3054         TRACE_INTERFACE_VTABLE (print_vtable_full (class, vtable, cur_slot, first_non_interface_slot, "AFTER INHERITING PARENT VTABLE", TRUE));
3055         /* override interface methods */
3056         for (i = 0; i < onum; i++) {
3057                 MonoMethod *decl = overrides [i*2];
3058                 if (MONO_CLASS_IS_INTERFACE (decl->klass)) {
3059                         int dslot;
3060                         dslot = mono_method_get_vtable_slot (decl) + mono_class_interface_offset (class, decl->klass);
3061                         vtable [dslot] = overrides [i*2 + 1];
3062                         vtable [dslot]->slot = dslot;
3063                         if (!override_map)
3064                                 override_map = g_hash_table_new (mono_aligned_addr_hash, NULL);
3065
3066                         g_hash_table_insert (override_map, overrides [i * 2], overrides [i * 2 + 1]);
3067
3068                         if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
3069                                 check_core_clr_override_method (class, vtable [dslot], decl);
3070                 }
3071         }
3072         TRACE_INTERFACE_VTABLE (print_overrides (override_map, "AFTER OVERRIDING INTERFACE METHODS"));
3073         TRACE_INTERFACE_VTABLE (print_vtable_full (class, vtable, cur_slot, first_non_interface_slot, "AFTER OVERRIDING INTERFACE METHODS", FALSE));
3074
3075         // Loop on all implemented interfaces...
3076         for (i = 0; i < class->interface_offsets_count; i++) {
3077                 MonoClass *parent = class->parent;
3078                 int ic_offset;
3079                 gboolean interface_is_explicitly_implemented_by_class;
3080                 int im_index;
3081
3082                 ic = class->interfaces_packed [i];
3083                 ic_offset = mono_class_interface_offset (class, ic);
3084
3085                 mono_class_setup_methods (ic);
3086
3087                 // Check if this interface is explicitly implemented (instead of just inherited)
3088                 if (parent != NULL) {
3089                         int implemented_interfaces_index;
3090                         interface_is_explicitly_implemented_by_class = FALSE;
3091                         for (implemented_interfaces_index = 0; implemented_interfaces_index < class->interface_count; implemented_interfaces_index++) {
3092                                 if (ic == class->interfaces [implemented_interfaces_index]) {
3093                                         interface_is_explicitly_implemented_by_class = TRUE;
3094                                         break;
3095                                 }
3096                         }
3097                 } else {
3098                         interface_is_explicitly_implemented_by_class = TRUE;
3099                 }
3100
3101                 // Loop on all interface methods...
3102                 for (im_index = 0; im_index < ic->method.count; im_index++) {
3103                         MonoMethod *im = ic->methods [im_index];
3104                         int im_slot = ic_offset + im->slot;
3105                         MonoMethod *override_im = (override_map != NULL) ? g_hash_table_lookup (override_map, im) : NULL;
3106
3107                         if (im->flags & METHOD_ATTRIBUTE_STATIC)
3108                                 continue;
3109
3110                         // If there is an explicit implementation, just use it right away,
3111                         // otherwise look for a matching method
3112                         if (override_im == NULL) {
3113                                 int cm_index;
3114                                 gpointer iter;
3115                                 MonoMethod *cm;
3116
3117                                 // First look for a suitable method among the class methods
3118                                 iter = NULL;
3119                                 while ((cm = mono_class_get_virtual_methods (class, &iter))) {
3120                                         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)));
3121                                         if (check_interface_method_override (class, im, cm, TRUE, interface_is_explicitly_implemented_by_class, (vtable [im_slot] == NULL), security_enabled)) {
3122                                                 TRACE_INTERFACE_VTABLE (printf ("[check ok]: ASSIGNING"));
3123                                                 vtable [im_slot] = cm;
3124                                                 /* Why do we need this? */
3125                                                 if (cm->slot < 0) {
3126                                                         cm->slot = im_slot;
3127                                                 }
3128                                         }
3129                                         TRACE_INTERFACE_VTABLE (printf ("\n"));
3130                                 }
3131
3132                                 // If the slot is still empty, look in all the inherited virtual methods...
3133                                 if ((vtable [im_slot] == NULL) && class->parent != NULL) {
3134                                         MonoClass *parent = class->parent;
3135                                         // Reverse order, so that last added methods are preferred
3136                                         for (cm_index = parent->vtable_size - 1; cm_index >= 0; cm_index--) {
3137                                                 MonoMethod *cm = parent->vtable [cm_index];
3138
3139                                                 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));
3140                                                 if ((cm != NULL) && check_interface_method_override (class, im, cm, FALSE, FALSE, TRUE, security_enabled)) {
3141                                                         TRACE_INTERFACE_VTABLE (printf ("[everything ok]: ASSIGNING"));
3142                                                         vtable [im_slot] = cm;
3143                                                         /* Why do we need this? */
3144                                                         if (cm->slot < 0) {
3145                                                                 cm->slot = im_slot;
3146                                                         }
3147                                                         break;
3148                                                 }
3149                                                 TRACE_INTERFACE_VTABLE ((cm != NULL) && printf ("\n"));
3150                                         }
3151                                 }
3152                         } else {
3153                                 g_assert (vtable [im_slot] == override_im);
3154                         }
3155                 }
3156         }
3157
3158         // If the class is not abstract, check that all its interface slots are full.
3159         // The check is done here and not directly at the end of the loop above because
3160         // it can happen (for injected generic array interfaces) that the same slot is
3161         // processed multiple times (those interfaces have overlapping slots), and it
3162         // will not always be the first pass the one that fills the slot.
3163         if (! (class->flags & TYPE_ATTRIBUTE_ABSTRACT)) {
3164                 for (i = 0; i < class->interface_offsets_count; i++) {
3165                         int ic_offset;
3166                         int im_index;
3167
3168                         ic = class->interfaces_packed [i];
3169                         ic_offset = mono_class_interface_offset (class, ic);
3170
3171                         for (im_index = 0; im_index < ic->method.count; im_index++) {
3172                                 MonoMethod *im = ic->methods [im_index];
3173                                 int im_slot = ic_offset + im->slot;
3174
3175                                 if (im->flags & METHOD_ATTRIBUTE_STATIC)
3176                                         continue;
3177
3178                                 TRACE_INTERFACE_VTABLE (printf ("      [class is not abstract, checking slot %d for interface '%s'.'%s', method %s, slot check is %d]\n",
3179                                                 im_slot, ic->name_space, ic->name, im->name, (vtable [im_slot] == NULL)));
3180                                 if (vtable [im_slot] == NULL) {
3181                                         print_unimplemented_interface_method_info (class, ic, im, im_slot, overrides, onum);
3182                                         mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL);
3183                                         if (override_map)
3184                                                 g_hash_table_destroy (override_map);
3185                                         return;
3186                                 }
3187                         }
3188                 }
3189         }
3190
3191         TRACE_INTERFACE_VTABLE (print_vtable_full (class, vtable, cur_slot, first_non_interface_slot, "AFTER SETTING UP INTERFACE METHODS", FALSE));
3192         class_iter = NULL;
3193         while ((cm = mono_class_get_virtual_methods (class, &class_iter))) {
3194                 /*
3195                  * If the method is REUSE_SLOT, we must check in the
3196                  * base class for a method to override.
3197                  */
3198                 if (!(cm->flags & METHOD_ATTRIBUTE_NEW_SLOT)) {
3199                         int slot = -1;
3200                         for (k = class->parent; k ; k = k->parent) {
3201                                 gpointer k_iter;
3202                                 MonoMethod *m1;
3203
3204                                 k_iter = NULL;
3205                                 while ((m1 = mono_class_get_virtual_methods (k, &k_iter))) {
3206                                         MonoMethodSignature *cmsig, *m1sig;
3207
3208                                         cmsig = mono_method_signature (cm);
3209                                         m1sig = mono_method_signature (m1);
3210
3211                                         if (!cmsig || !m1sig) {
3212                                                 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL);
3213                                                 return;
3214                                         }
3215
3216                                         if (!strcmp(cm->name, m1->name) &&
3217                                             mono_metadata_signature_equal (cmsig, m1sig)) {
3218
3219                                                 /* CAS - SecurityAction.InheritanceDemand */
3220                                                 if (security_enabled && (m1->flags & METHOD_ATTRIBUTE_HAS_SECURITY)) {
3221                                                         mono_secman_inheritancedemand_method (cm, m1);
3222                                                 }
3223
3224                                                 if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
3225                                                         check_core_clr_override_method (class, cm, m1);
3226
3227                                                 slot = mono_method_get_vtable_slot (m1);
3228                                                 g_assert (cm->slot < max_vtsize);
3229                                                 if (!override_map)
3230                                                         override_map = g_hash_table_new (mono_aligned_addr_hash, NULL);
3231                                                 g_hash_table_insert (override_map, m1, cm);
3232                                                 break;
3233                                         }
3234                                 }
3235                                 if (slot >= 0)
3236                                         break;
3237                         }
3238                         if (slot >= 0)
3239                                 cm->slot = slot;
3240                 }
3241
3242                 if (cm->slot < 0)
3243                         cm->slot = cur_slot++;
3244
3245                 if (!(cm->flags & METHOD_ATTRIBUTE_ABSTRACT))
3246                         vtable [cm->slot] = cm;
3247         }
3248
3249         /* override non interface methods */
3250         for (i = 0; i < onum; i++) {
3251                 MonoMethod *decl = overrides [i*2];
3252                 if (!MONO_CLASS_IS_INTERFACE (decl->klass)) {
3253                         g_assert (decl->slot != -1);
3254                         vtable [decl->slot] = overrides [i*2 + 1];
3255                         overrides [i * 2 + 1]->slot = decl->slot;
3256                         if (!override_map)
3257                                 override_map = g_hash_table_new (mono_aligned_addr_hash, NULL);
3258                         g_hash_table_insert (override_map, decl, overrides [i * 2 + 1]);
3259
3260                         if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
3261                                 check_core_clr_override_method (class, vtable [decl->slot], decl);
3262                 }
3263         }
3264
3265         /*
3266          * If a method occupies more than one place in the vtable, and it is
3267          * overriden, then change the other occurances too.
3268          */
3269         if (override_map) {
3270                 for (i = 0; i < max_vtsize; ++i)
3271                         if (vtable [i]) {
3272                                 MonoMethod *cm = g_hash_table_lookup (override_map, vtable [i]);
3273                                 if (cm)
3274                                         vtable [i] = cm;
3275                         }
3276
3277                 g_hash_table_destroy (override_map);
3278         }
3279
3280         if (class->generic_class) {
3281                 MonoClass *gklass = class->generic_class->container_class;
3282
3283                 mono_class_init (gklass);
3284
3285                 class->vtable_size = MAX (gklass->vtable_size, cur_slot);
3286         } else {
3287                 /* Check that the vtable_size value computed in mono_class_init () is correct */
3288                 if (class->vtable_size)
3289                         g_assert (cur_slot == class->vtable_size);
3290                 class->vtable_size = cur_slot;
3291         }
3292
3293         /* FIXME: only do this if the class is actually sharable */
3294         if (class->valuetype && (class->generic_class || class->generic_container) &&
3295                         mono_class_generic_sharing_enabled (class)) {
3296                 for (i = 0; i < max_vtsize; ++i) {
3297                         if (vtable [i] && vtable [i]->wrapper_type == MONO_WRAPPER_NONE)
3298                                 vtable [i] = mono_marshal_get_static_rgctx_invoke (vtable [i]);
3299                 }
3300         }
3301
3302         /* Try to share the vtable with our parent. */
3303         if (class->parent && (class->parent->vtable_size == class->vtable_size) && (memcmp (class->parent->vtable, vtable, sizeof (gpointer) * class->vtable_size) == 0)) {
3304                 mono_memory_barrier ();
3305                 class->vtable = class->parent->vtable;
3306         } else {
3307                 MonoMethod **tmp = mono_image_alloc0 (class->image, sizeof (gpointer) * class->vtable_size);
3308                 memcpy (tmp, vtable,  sizeof (gpointer) * class->vtable_size);
3309                 mono_memory_barrier ();
3310                 class->vtable = tmp;
3311         }
3312
3313         DEBUG_INTERFACE_VTABLE (print_vtable_full (class, class->vtable, class->vtable_size, first_non_interface_slot, "FINALLY", FALSE));
3314         if (mono_print_vtable) {
3315                 int icount = 0;
3316
3317                 print_implemented_interfaces (class);
3318
3319                 for (i = 0; i <= max_iid; i++)
3320                         if (MONO_CLASS_IMPLEMENTS_INTERFACE (class, i))
3321                                 icount++;
3322
3323                 printf ("VTable %s (vtable entries = %d, interfaces = %d)\n", mono_type_full_name (&class->byval_arg),
3324                         class->vtable_size, icount);
3325
3326                 for (i = 0; i < class->vtable_size; ++i) {
3327                         MonoMethod *cm;
3328
3329                         cm = vtable [i];
3330                         if (cm) {
3331                                 printf ("  slot assigned: %03d, slot index: %03d %s\n", i, cm->slot,
3332                                         mono_method_full_name (cm, TRUE));
3333                         }
3334                 }
3335
3336
3337                 if (icount) {
3338                         printf ("Interfaces %s.%s (max_iid = %d)\n", class->name_space,
3339                                 class->name, max_iid);
3340
3341                         for (i = 0; i < class->interface_count; i++) {
3342                                 ic = class->interfaces [i];
3343                                 printf ("  slot offset: %03d, method count: %03d, iid: %03d %s\n",
3344                                         mono_class_interface_offset (class, ic),
3345                                         ic->method.count, ic->interface_id, mono_type_full_name (&ic->byval_arg));
3346                         }
3347
3348                         for (k = class->parent; k ; k = k->parent) {
3349                                 for (i = 0; i < k->interface_count; i++) {
3350                                         ic = k->interfaces [i];
3351                                         printf ("  slot offset: %03d, method count: %03d, iid: %03d %s\n",
3352                                                 mono_class_interface_offset (class, ic),
3353                                                 ic->method.count, ic->interface_id, mono_type_full_name (&ic->byval_arg));
3354                                 }
3355                         }
3356                 }
3357         }
3358
3359         VERIFY_INTERFACE_VTABLE (mono_class_verify_vtable (class));
3360 }
3361
3362 /*
3363  * mono_method_get_vtable_slot:
3364  *
3365  *   Returns method->slot, computing it if neccesary.
3366  * LOCKING: Acquires the loader lock.
3367  */
3368 int
3369 mono_method_get_vtable_slot (MonoMethod *method)
3370 {
3371         if (method->slot == -1) {
3372                 mono_class_setup_vtable (method->klass);
3373                 g_assert (method->slot != -1);
3374         }
3375         return method->slot;
3376 }
3377
3378 /**
3379  * mono_method_get_vtable_index:
3380  * @method: a method
3381  *
3382  * Returns the index into the runtime vtable to access the method or,
3383  * in the case of a virtual generic method, the virtual generic method
3384  * thunk.
3385  */
3386 int
3387 mono_method_get_vtable_index (MonoMethod *method)
3388 {
3389         if (method->is_inflated && (method->flags & METHOD_ATTRIBUTE_VIRTUAL)) {
3390                 MonoMethodInflated *imethod = (MonoMethodInflated*)method;
3391                 if (imethod->declaring->is_generic)
3392                         return mono_method_get_vtable_slot (imethod->declaring);
3393         }
3394         return mono_method_get_vtable_slot (method);
3395 }
3396
3397 static MonoMethod *default_ghc = NULL;
3398 static MonoMethod *default_finalize = NULL;
3399 static int finalize_slot = -1;
3400 static int ghc_slot = -1;
3401
3402 static void
3403 initialize_object_slots (MonoClass *class)
3404 {
3405         int i;
3406         if (default_ghc)
3407                 return;
3408         if (class == mono_defaults.object_class) {
3409                 mono_class_setup_vtable (class);
3410                 for (i = 0; i < class->vtable_size; ++i) {
3411                         MonoMethod *cm = class->vtable [i];
3412
3413                         if (!strcmp (cm->name, "GetHashCode"))
3414                                 ghc_slot = i;
3415                         else if (!strcmp (cm->name, "Finalize"))
3416                                 finalize_slot = i;
3417                 }
3418
3419                 g_assert (ghc_slot > 0);
3420                 default_ghc = class->vtable [ghc_slot];
3421
3422                 g_assert (finalize_slot > 0);
3423                 default_finalize = class->vtable [finalize_slot];
3424         }
3425 }
3426
3427 static GList*
3428 g_list_prepend_mempool (GList* l, MonoMemPool* mp, gpointer datum)
3429 {
3430         GList* n = mono_mempool_alloc (mp, sizeof (GList));
3431         n->next = l;
3432         n->prev = NULL;
3433         n->data = datum;
3434         return n;
3435 }
3436
3437 typedef struct {
3438         MonoMethod *array_method;
3439         char *name;
3440 } GenericArrayMethodInfo;
3441
3442 static int generic_array_method_num = 0;
3443 static GenericArrayMethodInfo *generic_array_method_info = NULL;
3444
3445 static int
3446 generic_array_methods (MonoClass *class)
3447 {
3448         int i, count_generic = 0;
3449         GList *list = NULL, *tmp;
3450         if (generic_array_method_num)
3451                 return generic_array_method_num;
3452         mono_class_setup_methods (class->parent);
3453         for (i = 0; i < class->parent->method.count; i++) {
3454                 MonoMethod *m = class->parent->methods [i];
3455                 if (!strncmp (m->name, "InternalArray__", 15)) {
3456                         count_generic++;
3457                         list = g_list_prepend (list, m);
3458                 }
3459         }
3460         list = g_list_reverse (list);
3461         generic_array_method_info = g_malloc (sizeof (GenericArrayMethodInfo) * count_generic);
3462         i = 0;
3463         for (tmp = list; tmp; tmp = tmp->next) {
3464                 const char *mname, *iname;
3465                 gchar *name;
3466                 MonoMethod *m = tmp->data;
3467                 generic_array_method_info [i].array_method = m;
3468                 if (!strncmp (m->name, "InternalArray__ICollection_", 27)) {
3469                         iname = "System.Collections.Generic.ICollection`1.";
3470                         mname = m->name + 27;
3471                 } else if (!strncmp (m->name, "InternalArray__IEnumerable_", 27)) {
3472                         iname = "System.Collections.Generic.IEnumerable`1.";
3473                         mname = m->name + 27;
3474                 } else if (!strncmp (m->name, "InternalArray__", 15)) {
3475                         iname = "System.Collections.Generic.IList`1.";
3476                         mname = m->name + 15;
3477                 } else {
3478                         g_assert_not_reached ();
3479                 }
3480
3481                 name = mono_image_alloc (mono_defaults.corlib, strlen (iname) + strlen (mname) + 1);
3482                 strcpy (name, iname);
3483                 strcpy (name + strlen (iname), mname);
3484                 generic_array_method_info [i].name = name;
3485                 i++;
3486         }
3487         /*g_print ("array generic methods: %d\n", count_generic);*/
3488
3489         generic_array_method_num = count_generic;
3490         g_list_free (list);
3491         return generic_array_method_num;
3492 }
3493
3494 static void
3495 setup_generic_array_ifaces (MonoClass *class, MonoClass *iface, MonoMethod **methods, int pos)
3496 {
3497         MonoGenericContext tmp_context;
3498         int i;
3499
3500         tmp_context.class_inst = NULL;
3501         tmp_context.method_inst = iface->generic_class->context.class_inst;
3502         //g_print ("setting up array interface: %s\n", mono_type_get_name_full (&iface->byval_arg, 0));
3503
3504         for (i = 0; i < generic_array_method_num; i++) {
3505                 MonoMethod *m = generic_array_method_info [i].array_method;
3506                 MonoMethod *inflated;
3507
3508                 inflated = mono_class_inflate_generic_method (m, &tmp_context);
3509                 methods [pos++] = mono_marshal_get_generic_array_helper (class, iface, generic_array_method_info [i].name, inflated);
3510         }
3511 }
3512
3513 static char*
3514 concat_two_strings_with_zero (MonoImage *image, const char *s1, const char *s2)
3515 {
3516         int len = strlen (s1) + strlen (s2) + 2;
3517         char *s = mono_image_alloc (image, len);
3518         int result;
3519
3520         result = g_snprintf (s, len, "%s%c%s", s1, '\0', s2);
3521         g_assert (result == len - 1);
3522
3523         return s;
3524 }
3525
3526 static void
3527 set_failure_from_loader_error (MonoClass *class, MonoLoaderError *error)
3528 {
3529         gpointer exception_data = NULL;
3530
3531         switch (error->exception_type) {
3532         case MONO_EXCEPTION_TYPE_LOAD:
3533                 exception_data = concat_two_strings_with_zero (class->image, error->class_name, error->assembly_name);
3534                 break;
3535
3536         case MONO_EXCEPTION_MISSING_METHOD:
3537                 exception_data = concat_two_strings_with_zero (class->image, error->class_name, error->member_name);
3538                 break;
3539
3540         case MONO_EXCEPTION_MISSING_FIELD: {
3541                 const char *name_space = error->klass->name_space ? error->klass->name_space : NULL;
3542                 const char *class_name;
3543
3544                 if (name_space)
3545                         class_name = g_strdup_printf ("%s.%s", name_space, error->klass->name);
3546                 else
3547                         class_name = error->klass->name;
3548
3549                 exception_data = concat_two_strings_with_zero (class->image, class_name, error->member_name);
3550
3551                 if (name_space)
3552                         g_free ((void*)class_name);
3553                 break;
3554         }
3555
3556         case MONO_EXCEPTION_FILE_NOT_FOUND: {
3557                 const char *msg;
3558
3559                 if (error->ref_only)
3560                         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.";
3561                 else
3562                         msg = "Could not load file or assembly '%s' or one of its dependencies.";
3563
3564                 exception_data = concat_two_strings_with_zero (class->image, msg, error->assembly_name);
3565                 break;
3566         }
3567
3568         case MONO_EXCEPTION_BAD_IMAGE:
3569                 exception_data = error->msg;
3570                 break;
3571
3572         default :
3573                 g_assert_not_reached ();
3574         }
3575
3576         mono_class_set_failure (class, error->exception_type, exception_data);
3577 }
3578
3579 static void
3580 check_core_clr_inheritance (MonoClass *class)
3581 {
3582         MonoSecurityCoreCLRLevel class_level, parent_level;
3583         MonoClass *parent = class->parent;
3584
3585         if (!parent)
3586                 return;
3587
3588         class_level = mono_security_core_clr_class_level (class);
3589         parent_level = mono_security_core_clr_class_level (parent);
3590
3591         if (class_level < parent_level)
3592                 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL);
3593 }
3594
3595 /**
3596  * mono_class_init:
3597  * @class: the class to initialize
3598  *
3599  *   Compute the instance_size, class_size and other infos that cannot be
3600  * computed at mono_class_get() time. Also compute vtable_size if possible.
3601  * Returns TRUE on success or FALSE if there was a problem in loading
3602  * the type (incorrect assemblies, missing assemblies, methods, etc).
3603  *
3604  * LOCKING: Acquires the loader lock.
3605  */
3606 gboolean
3607 mono_class_init (MonoClass *class)
3608 {
3609         int i;
3610         MonoCachedClassInfo cached_info;
3611         gboolean has_cached_info;
3612         int class_init_ok = TRUE;
3613
3614         g_assert (class);
3615
3616         /* Double-checking locking pattern */
3617         if (class->inited)
3618                 return class->exception_type == MONO_EXCEPTION_NONE;
3619
3620         /*g_print ("Init class %s\n", class->name);*/
3621
3622         /* We do everything inside the lock to prevent races */
3623         mono_loader_lock ();
3624
3625         if (class->inited) {
3626                 mono_loader_unlock ();
3627                 /* Somebody might have gotten in before us */
3628                 return class->exception_type == MONO_EXCEPTION_NONE;
3629         }
3630
3631         if (class->init_pending) {
3632                 mono_loader_unlock ();
3633                 /* this indicates a cyclic dependency */
3634                 g_error ("pending init %s.%s\n", class->name_space, class->name);
3635         }
3636
3637         class->init_pending = 1;
3638
3639         /* CAS - SecurityAction.InheritanceDemand */
3640         if (mono_is_security_manager_active () && class->parent && (class->parent->flags & TYPE_ATTRIBUTE_HAS_SECURITY)) {
3641                 mono_secman_inheritancedemand_class (class, class->parent);
3642         }
3643
3644         if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
3645                 check_core_clr_inheritance (class);
3646
3647         mono_stats.initialized_class_count++;
3648
3649         if (class->generic_class && !class->generic_class->is_dynamic) {
3650                 MonoClass *gklass = class->generic_class->container_class;
3651
3652                 mono_stats.generic_class_count++;
3653
3654                 class->method = gklass->method;
3655                 class->field = gklass->field;
3656
3657                 mono_class_init (gklass);
3658                 // FIXME: Why is this needed ?
3659                 mono_class_setup_methods (gklass);
3660
3661                 if (MONO_CLASS_IS_INTERFACE (class))
3662                         class->interface_id = mono_get_unique_iid (class);
3663
3664                 g_assert (class->interface_count == gklass->interface_count);
3665         }
3666
3667         if (class->parent && !class->parent->inited)
3668                 mono_class_init (class->parent);
3669
3670         has_cached_info = mono_class_get_cached_class_info (class, &cached_info);
3671
3672         if (class->generic_class || class->image->dynamic || !class->type_token || (has_cached_info && !cached_info.has_nested_classes))
3673                 class->nested_classes_inited = TRUE;
3674
3675         /*
3676          * Computes the size used by the fields, and their locations
3677          */
3678         if (has_cached_info) {
3679                 class->instance_size = cached_info.instance_size;
3680                 class->sizes.class_size = cached_info.class_size;
3681                 class->packing_size = cached_info.packing_size;
3682                 class->min_align = cached_info.min_align;
3683                 class->blittable = cached_info.blittable;
3684                 class->has_references = cached_info.has_references;
3685                 class->has_static_refs = cached_info.has_static_refs;
3686                 class->no_special_static_fields = cached_info.no_special_static_fields;
3687         }
3688         else
3689                 if (!class->size_inited){
3690                         mono_class_setup_fields (class);
3691                         if (class->exception_type || mono_loader_get_last_error ()){
3692                                 class_init_ok = FALSE;
3693                                 goto leave;
3694                         }
3695                 }
3696
3697         /* Initialize arrays */
3698         if (class->rank) {
3699                 class->method.count = 3 + (class->rank > 1? 2: 1);
3700
3701                 if (class->interface_count) {
3702                         int count_generic = generic_array_methods (class);
3703                         class->method.count += class->interface_count * count_generic;
3704                 }
3705         }
3706
3707         mono_class_setup_supertypes (class);
3708
3709         if (!default_ghc)
3710                 initialize_object_slots (class);
3711
3712         /*
3713          * Initialize the rest of the data without creating a generic vtable if possible.
3714          * If possible, also compute vtable_size, so mono_class_create_runtime_vtable () can
3715          * also avoid computing a generic vtable.
3716          */
3717         if (has_cached_info) {
3718                 /* AOT case */
3719                 class->vtable_size = cached_info.vtable_size;
3720                 class->has_finalize = cached_info.has_finalize;
3721                 class->ghcimpl = cached_info.ghcimpl;
3722                 class->has_cctor = cached_info.has_cctor;
3723         } else if (class->rank == 1 && class->byval_arg.type == MONO_TYPE_SZARRAY) {
3724                 static int szarray_vtable_size = 0;
3725
3726                 /* SZARRAY case */
3727                 if (!szarray_vtable_size) {
3728                         mono_class_setup_vtable (class);
3729                         szarray_vtable_size = class->vtable_size;
3730                 } else {
3731                         class->vtable_size = szarray_vtable_size;
3732                 }
3733         } else if (class->generic_class && !MONO_CLASS_IS_INTERFACE (class)) {
3734                 MonoClass *gklass = class->generic_class->container_class;
3735
3736                 /* Generic instance case */
3737                 class->ghcimpl = gklass->ghcimpl;
3738                 class->has_finalize = gklass->has_finalize;
3739                 class->has_cctor = gklass->has_cctor;
3740
3741                 mono_class_setup_vtable (gklass);
3742                 if (gklass->exception_type)
3743                         goto fail;
3744
3745                 class->vtable_size = gklass->vtable_size;
3746         } else {
3747                 /* General case */
3748
3749                 /* ghcimpl is not currently used
3750                 class->ghcimpl = 1;
3751                 if (class->parent) {
3752                         MonoMethod *cmethod = class->vtable [ghc_slot];
3753                         if (cmethod->is_inflated)
3754                                 cmethod = ((MonoMethodInflated*)cmethod)->declaring;
3755                         if (cmethod == default_ghc) {
3756                                 class->ghcimpl = 0;
3757                         }
3758                 }
3759                 */
3760
3761                 /* Interfaces and valuetypes are not supposed to have finalizers */
3762                 if (!(MONO_CLASS_IS_INTERFACE (class) || class->valuetype)) {
3763                         MonoMethod *cmethod = NULL;
3764
3765                         if (class->parent && class->parent->has_finalize) {
3766                                 class->has_finalize = 1;
3767                         } else {
3768                                 if (class->type_token) {
3769                                         cmethod = find_method_in_metadata (class, "Finalize", 0, METHOD_ATTRIBUTE_VIRTUAL);
3770                                 } else if (class->parent) {
3771                                         /* FIXME: Optimize this */
3772                                         mono_class_setup_vtable (class);
3773                                         if (class->exception_type || mono_loader_get_last_error ())
3774                                                 goto fail;
3775                                         cmethod = class->vtable [finalize_slot];
3776                                 }
3777
3778                                 if (cmethod) {
3779                                         /* Check that this is really the finalizer method */
3780                                         mono_class_setup_vtable (class);
3781                                         if (class->exception_type || mono_loader_get_last_error ())
3782                                         goto fail;
3783
3784                                         class->has_finalize = 0;
3785                                         if (class->parent) {
3786                                                 cmethod = class->vtable [finalize_slot];
3787                                                 if (cmethod->is_inflated)
3788                                                         cmethod = ((MonoMethodInflated*)cmethod)->declaring;
3789                                                 if (cmethod != default_finalize) {
3790                                                         class->has_finalize = 1;
3791                                                 }
3792                                         }
3793                                 }
3794                         }
3795                 }
3796
3797                 /* C# doesn't allow interfaces to have cctors */
3798                 if (!MONO_CLASS_IS_INTERFACE (class) || class->image != mono_defaults.corlib) {
3799                         MonoMethod *cmethod = NULL;
3800
3801                         if (class->type_token) {
3802                                 cmethod = find_method_in_metadata (class, ".cctor", 0, METHOD_ATTRIBUTE_SPECIAL_NAME);
3803                                 /* The find_method function ignores the 'flags' argument */
3804                                 if (cmethod && (cmethod->flags & METHOD_ATTRIBUTE_SPECIAL_NAME))
3805                                         class->has_cctor = 1;
3806                         } else {
3807                                 mono_class_setup_methods (class);
3808
3809                                 for (i = 0; i < class->method.count; ++i) {
3810                                         MonoMethod *method = class->methods [i];
3811                                         if ((method->flags & METHOD_ATTRIBUTE_SPECIAL_NAME) &&
3812                                                 (strcmp (".cctor", method->name) == 0)) {
3813                                                 class->has_cctor = 1;
3814                                                 break;
3815                                         }
3816                                 }
3817                         }
3818                 }
3819         }
3820
3821         if (!mono_setup_vtable_in_class_init) {
3822                 /*
3823                  * This is an embedding API break, since the caller might assume that
3824                  * mono_class_init () constructs a generic vtable, so vtable construction errors
3825                  * are visible right after the mono_class_init (), and not after
3826                  * mono_class_vtable ().
3827                  */
3828                 if (class->parent) {
3829                         /* This will compute class->parent->vtable_size for some classes */
3830                         mono_class_init (class->parent);
3831                         if (class->parent->exception_type || mono_loader_get_last_error ())
3832                                 goto fail;
3833                         if (!class->parent->vtable_size) {
3834                                 /* FIXME: Get rid of this somehow */
3835                                 mono_class_setup_vtable (class->parent);
3836                                 if (class->parent->exception_type || mono_loader_get_last_error ())
3837                                         goto fail;
3838                         }
3839                         setup_interface_offsets (class, class->parent->vtable_size);
3840                 } else {
3841                         setup_interface_offsets (class, 0);
3842                 }
3843         } else {
3844                 mono_class_setup_vtable (class);
3845
3846                 if (MONO_CLASS_IS_INTERFACE (class))
3847                         setup_interface_offsets (class, 0);
3848         }
3849
3850         if (mono_verifier_is_enabled_for_class (class) && !mono_verifier_verify_class (class)) {
3851                 mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, concat_two_strings_with_zero (class->image, class->name, class->image->assembly_name));
3852                 class_init_ok = FALSE;
3853         }
3854
3855         goto leave;
3856
3857  fail:
3858         class_init_ok = FALSE;
3859
3860  leave:
3861         /* Because of the double-checking locking pattern */
3862         mono_memory_barrier ();
3863         class->inited = 1;
3864         class->init_pending = 0;
3865
3866         if (mono_loader_get_last_error ()) {
3867                 if (class->exception_type == MONO_EXCEPTION_NONE)
3868                         set_failure_from_loader_error (class, mono_loader_get_last_error ());
3869
3870                 mono_loader_clear_error ();
3871         }
3872
3873         mono_loader_unlock ();
3874
3875         if (mono_debugger_class_init_func)
3876                 mono_debugger_class_init_func (class);
3877
3878         return class_init_ok;
3879 }
3880
3881 static gboolean
3882 is_corlib_image (MonoImage *image)
3883 {
3884         /* FIXME: allow the dynamic case for our compilers and with full trust */
3885         if (image->dynamic)
3886                 return image->assembly && !strcmp (image->assembly->aname.name, "mscorlib");
3887         else
3888                 return image == mono_defaults.corlib;
3889 }
3890
3891 /*
3892  * LOCKING: this assumes the loader lock is held
3893  */
3894 void
3895 mono_class_setup_mono_type (MonoClass *class)
3896 {
3897         const char *name = class->name;
3898         const char *nspace = class->name_space;
3899         gboolean is_corlib = is_corlib_image (class->image);
3900
3901         class->this_arg.byref = 1;
3902         class->this_arg.data.klass = class;
3903         class->this_arg.type = MONO_TYPE_CLASS;
3904         class->byval_arg.data.klass = class;
3905         class->byval_arg.type = MONO_TYPE_CLASS;
3906
3907         if (is_corlib && !strcmp (nspace, "System")) {
3908                 if (!strcmp (name, "ValueType")) {
3909                         /*
3910                          * do not set the valuetype bit for System.ValueType.
3911                          * class->valuetype = 1;
3912                          */
3913                         class->blittable = TRUE;
3914                 } else if (!strcmp (name, "Enum")) {
3915                         /*
3916                          * do not set the valuetype bit for System.Enum.
3917                          * class->valuetype = 1;
3918                          */
3919                         class->valuetype = 0;
3920                         class->enumtype = 0;
3921                 } else if (!strcmp (name, "Object")) {
3922                         class->this_arg.type = class->byval_arg.type = MONO_TYPE_OBJECT;
3923                 } else if (!strcmp (name, "String")) {
3924                         class->this_arg.type = class->byval_arg.type = MONO_TYPE_STRING;
3925                 } else if (!strcmp (name, "TypedReference")) {
3926                         class->this_arg.type = class->byval_arg.type = MONO_TYPE_TYPEDBYREF;
3927                 }
3928         }
3929
3930         if (class->valuetype) {
3931                 int t = MONO_TYPE_VALUETYPE;
3932
3933                 if (is_corlib && !strcmp (nspace, "System")) {
3934                         switch (*name) {
3935                         case 'B':
3936                                 if (!strcmp (name, "Boolean")) {
3937                                         t = MONO_TYPE_BOOLEAN;
3938                                 } else if (!strcmp(name, "Byte")) {
3939                                         t = MONO_TYPE_U1;
3940                                         class->blittable = TRUE;
3941                                 }
3942                                 break;
3943                         case 'C':
3944                                 if (!strcmp (name, "Char")) {
3945                                         t = MONO_TYPE_CHAR;
3946                                 }
3947                                 break;
3948                         case 'D':
3949                                 if (!strcmp (name, "Double")) {
3950                                         t = MONO_TYPE_R8;
3951                                         class->blittable = TRUE;
3952                                 }
3953                                 break;
3954                         case 'I':
3955                                 if (!strcmp (name, "Int32")) {
3956                                         t = MONO_TYPE_I4;
3957                                         class->blittable = TRUE;
3958                                 } else if (!strcmp(name, "Int16")) {
3959                                         t = MONO_TYPE_I2;
3960                                         class->blittable = TRUE;
3961                                 } else if (!strcmp(name, "Int64")) {
3962                                         t = MONO_TYPE_I8;
3963                                         class->blittable = TRUE;
3964                                 } else if (!strcmp(name, "IntPtr")) {
3965                                         t = MONO_TYPE_I;
3966                                         class->blittable = TRUE;
3967                                 }
3968                                 break;
3969                         case 'S':
3970                                 if (!strcmp (name, "Single")) {
3971                                         t = MONO_TYPE_R4;
3972                                         class->blittable = TRUE;
3973                                 } else if (!strcmp(name, "SByte")) {
3974                                         t = MONO_TYPE_I1;
3975                                         class->blittable = TRUE;
3976                                 }
3977                                 break;
3978                         case 'U':
3979                                 if (!strcmp (name, "UInt32")) {
3980                                         t = MONO_TYPE_U4;
3981                                         class->blittable = TRUE;
3982                                 } else if (!strcmp(name, "UInt16")) {
3983                                         t = MONO_TYPE_U2;
3984                                         class->blittable = TRUE;
3985                                 } else if (!strcmp(name, "UInt64")) {
3986                                         t = MONO_TYPE_U8;
3987                                         class->blittable = TRUE;
3988                                 } else if (!strcmp(name, "UIntPtr")) {
3989                                         t = MONO_TYPE_U;
3990                                         class->blittable = TRUE;
3991                                 }
3992                                 break;
3993                         case 'T':
3994                                 if (!strcmp (name, "TypedReference")) {
3995                                         t = MONO_TYPE_TYPEDBYREF;
3996                                         class->blittable = TRUE;
3997                                 }
3998                                 break;
3999                         case 'V':
4000                                 if (!strcmp (name, "Void")) {
4001                                         t = MONO_TYPE_VOID;
4002                                 }
4003                                 break;
4004                         default:
4005                                 break;
4006                         }
4007                 }
4008                 class->this_arg.type = class->byval_arg.type = t;
4009         }
4010
4011         if (MONO_CLASS_IS_INTERFACE (class))
4012                 class->interface_id = mono_get_unique_iid (class);
4013
4014 }
4015
4016 /*
4017  * LOCKING: this assumes the loader lock is held
4018  */
4019 void
4020 mono_class_setup_parent (MonoClass *class, MonoClass *parent)
4021 {
4022         gboolean system_namespace;
4023         gboolean is_corlib = is_corlib_image (class->image);
4024
4025         system_namespace = !strcmp (class->name_space, "System") && is_corlib;
4026
4027         /* if root of the hierarchy */
4028         if (system_namespace && !strcmp (class->name, "Object")) {
4029                 class->parent = NULL;
4030                 class->instance_size = sizeof (MonoObject);
4031                 return;
4032         }
4033         if (!strcmp (class->name, "<Module>")) {
4034                 class->parent = NULL;
4035                 class->instance_size = 0;
4036                 return;
4037         }
4038
4039         if (!MONO_CLASS_IS_INTERFACE (class)) {
4040                 /* Imported COM Objects always derive from __ComObject. */
4041                 if (MONO_CLASS_IS_IMPORT (class)) {
4042                         mono_init_com_types ();
4043                         if (parent == mono_defaults.object_class)
4044                                 parent = mono_defaults.com_object_class;
4045                 }
4046                 if (!parent) {
4047                         /* set the parent to something useful and safe, but mark the type as broken */
4048                         parent = mono_defaults.object_class;
4049                         mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL);
4050                 }
4051
4052                 class->parent = parent;
4053
4054                 if (parent->generic_class && !parent->name) {
4055                         /*
4056                          * If the parent is a generic instance, we may get
4057                          * called before it is fully initialized, especially
4058                          * before it has its name.
4059                          */
4060                         return;
4061                 }
4062
4063                 class->marshalbyref = parent->marshalbyref;
4064                 class->contextbound  = parent->contextbound;
4065                 class->delegate  = parent->delegate;
4066                 if (MONO_CLASS_IS_IMPORT (class))
4067                         class->is_com_object = 1;
4068                 else
4069                         class->is_com_object = parent->is_com_object;
4070
4071                 if (system_namespace) {
4072                         if (*class->name == 'M' && !strcmp (class->name, "MarshalByRefObject"))
4073                                 class->marshalbyref = 1;
4074
4075                         if (*class->name == 'C' && !strcmp (class->name, "ContextBoundObject"))
4076                                 class->contextbound  = 1;
4077
4078                         if (*class->name == 'D' && !strcmp (class->name, "Delegate"))
4079                                 class->delegate  = 1;
4080                 }
4081
4082                 if (class->parent->enumtype || (is_corlib_image (class->parent->image) && (strcmp (class->parent->name, "ValueType") == 0) &&
4083                                                 (strcmp (class->parent->name_space, "System") == 0)))
4084                         class->valuetype = 1;
4085                 if (is_corlib_image (class->parent->image) && ((strcmp (class->parent->name, "Enum") == 0) && (strcmp (class->parent->name_space, "System") == 0))) {
4086                         class->valuetype = class->enumtype = 1;
4087                 }
4088                 /*class->enumtype = class->parent->enumtype; */
4089                 mono_class_setup_supertypes (class);
4090         } else {
4091                 /* initialize com types if COM interfaces are present */
4092                 if (MONO_CLASS_IS_IMPORT (class))
4093                         mono_init_com_types ();
4094                 class->parent = NULL;
4095         }
4096
4097 }
4098
4099 /*
4100  * mono_class_setup_supertypes:
4101  * @class: a class
4102  *
4103  * Build the data structure needed to make fast type checks work.
4104  * This currently sets two fields in @class:
4105  *  - idepth: distance between @class and System.Object in the type
4106  *    hierarchy + 1
4107  *  - supertypes: array of classes: each element has a class in the hierarchy
4108  *    starting from @class up to System.Object
4109  *
4110  * LOCKING: this assumes the loader lock is held
4111  */
4112 void
4113 mono_class_setup_supertypes (MonoClass *class)
4114 {
4115         int ms;
4116
4117         if (class->supertypes)
4118                 return;
4119
4120         if (class->parent && !class->parent->supertypes)
4121                 mono_class_setup_supertypes (class->parent);
4122         if (class->parent)
4123                 class->idepth = class->parent->idepth + 1;
4124         else
4125                 class->idepth = 1;
4126
4127         ms = MAX (MONO_DEFAULT_SUPERTABLE_SIZE, class->idepth);
4128         class->supertypes = mono_image_alloc0 (class->image, sizeof (MonoClass *) * ms);
4129
4130         if (class->parent) {
4131                 class->supertypes [class->idepth - 1] = class;
4132                 memcpy (class->supertypes, class->parent->supertypes, class->parent->idepth * sizeof (gpointer));
4133         } else {
4134                 class->supertypes [0] = class;
4135         }
4136 }
4137
4138 /**
4139  * mono_class_create_from_typedef:
4140  * @image: image where the token is valid
4141  * @type_token:  typedef token
4142  *
4143  * Create the MonoClass* representing the specified type token.
4144  * @type_token must be a TypeDef token.
4145  */
4146 static MonoClass *
4147 mono_class_create_from_typedef (MonoImage *image, guint32 type_token)
4148 {
4149         MonoTableInfo *tt = &image->tables [MONO_TABLE_TYPEDEF];
4150         MonoClass *class, *parent = NULL;
4151         guint32 cols [MONO_TYPEDEF_SIZE];
4152         guint32 cols_next [MONO_TYPEDEF_SIZE];
4153         guint tidx = mono_metadata_token_index (type_token);
4154         MonoGenericContext *context = NULL;
4155         const char *name, *nspace;
4156         guint icount = 0;
4157         MonoClass **interfaces;
4158         guint32 field_last, method_last;
4159         guint32 nesting_tokeen;
4160
4161         mono_loader_lock ();
4162
4163         if ((class = mono_internal_hash_table_lookup (&image->class_cache, GUINT_TO_POINTER (type_token)))) {
4164                 mono_loader_unlock ();
4165                 return class;
4166         }
4167
4168         g_assert (mono_metadata_token_table (type_token) == MONO_TABLE_TYPEDEF);
4169
4170         mono_metadata_decode_row (tt, tidx - 1, cols, MONO_TYPEDEF_SIZE);
4171
4172         name = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAME]);
4173         nspace = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAMESPACE]);
4174
4175         class = mono_image_alloc0 (image, sizeof (MonoClass));
4176
4177         class->name = name;
4178         class->name_space = nspace;
4179
4180         mono_profiler_class_event (class, MONO_PROFILE_START_LOAD);
4181
4182         class->image = image;
4183         class->type_token = type_token;
4184         class->flags = cols [MONO_TYPEDEF_FLAGS];
4185
4186         mono_internal_hash_table_insert (&image->class_cache, GUINT_TO_POINTER (type_token), class);
4187
4188         /*
4189          * Check whether we're a generic type definition.
4190          */
4191         class->generic_container = mono_metadata_load_generic_params (image, class->type_token, NULL);
4192         if (class->generic_container) {
4193                 class->generic_container->owner.klass = class;
4194                 context = &class->generic_container->context;
4195         }
4196
4197         if (cols [MONO_TYPEDEF_EXTENDS]) {
4198                 parent = mono_class_get_full (
4199                         image, mono_metadata_token_from_dor (cols [MONO_TYPEDEF_EXTENDS]), context);
4200                 if (parent == NULL){
4201                         mono_internal_hash_table_remove (&image->class_cache, GUINT_TO_POINTER (type_token));
4202                         mono_loader_unlock ();
4203                         mono_profiler_class_loaded (class, MONO_PROFILE_FAILED);
4204                         return NULL;
4205                 }
4206         }
4207
4208         /* do this early so it's available for interfaces in setup_mono_type () */
4209         if ((nesting_tokeen = mono_metadata_nested_in_typedef (image, type_token)))
4210                 class->nested_in = mono_class_create_from_typedef (image, nesting_tokeen);
4211
4212         mono_class_setup_parent (class, parent);
4213
4214         /* uses ->valuetype, which is initialized by mono_class_setup_parent above */
4215         mono_class_setup_mono_type (class);
4216
4217         if (!class->enumtype) {
4218                 if (!mono_metadata_interfaces_from_typedef_full (
4219                             image, type_token, &interfaces, &icount, context)){
4220                         mono_loader_unlock ();
4221                         mono_profiler_class_loaded (class, MONO_PROFILE_FAILED);
4222                         return NULL;
4223                 }
4224
4225                 class->interfaces = interfaces;
4226                 class->interface_count = icount;
4227         }
4228
4229         if ((class->flags & TYPE_ATTRIBUTE_STRING_FORMAT_MASK) == TYPE_ATTRIBUTE_UNICODE_CLASS)
4230                 class->unicode = 1;
4231
4232 #if PLATFORM_WIN32
4233         if ((class->flags & TYPE_ATTRIBUTE_STRING_FORMAT_MASK) == TYPE_ATTRIBUTE_AUTO_CLASS)
4234                 class->unicode = 1;
4235 #endif
4236
4237         class->cast_class = class->element_class = class;
4238
4239         /*g_print ("Load class %s\n", name);*/
4240
4241         /*
4242          * Compute the field and method lists
4243          */
4244         class->field.first  = cols [MONO_TYPEDEF_FIELD_LIST] - 1;
4245         class->method.first = cols [MONO_TYPEDEF_METHOD_LIST] - 1;
4246
4247         if (tt->rows > tidx){
4248                 mono_metadata_decode_row (tt, tidx, cols_next, MONO_TYPEDEF_SIZE);
4249                 field_last  = cols_next [MONO_TYPEDEF_FIELD_LIST] - 1;
4250                 method_last = cols_next [MONO_TYPEDEF_METHOD_LIST] - 1;
4251         } else {
4252                 field_last  = image->tables [MONO_TABLE_FIELD].rows;
4253                 method_last = image->tables [MONO_TABLE_METHOD].rows;
4254         }
4255
4256         if (cols [MONO_TYPEDEF_FIELD_LIST] &&
4257             cols [MONO_TYPEDEF_FIELD_LIST] <= image->tables [MONO_TABLE_FIELD].rows)
4258                 class->field.count = field_last - class->field.first;
4259         else
4260                 class->field.count = 0;
4261
4262         if (cols [MONO_TYPEDEF_METHOD_LIST] <= image->tables [MONO_TABLE_METHOD].rows)
4263                 class->method.count = method_last - class->method.first;
4264         else
4265                 class->method.count = 0;
4266
4267         /* reserve space to store vector pointer in arrays */
4268         if (!strcmp (nspace, "System") && !strcmp (name, "Array")) {
4269                 class->instance_size += 2 * sizeof (gpointer);
4270                 g_assert (class->field.count == 0);
4271         }
4272
4273         if (class->enumtype) {
4274                 class->enum_basetype = mono_class_find_enum_basetype (class);
4275                 if (!class->enum_basetype) {
4276                         mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL);
4277                         mono_loader_unlock ();
4278                         return NULL;
4279                 }
4280                 class->cast_class = class->element_class = mono_class_from_mono_type (class->enum_basetype);
4281         }
4282
4283         /*
4284          * If we're a generic type definition, load the constraints.
4285          * We must do this after the class has been constructed to make certain recursive scenarios
4286          * work.
4287          */
4288         if (class->generic_container)
4289                 mono_metadata_load_generic_param_constraints (
4290                         image, type_token, class->generic_container);
4291
4292         if (class->image->assembly_name && !strcmp (class->image->assembly_name, "Mono.Simd") && !strcmp (nspace, "Mono.Simd")) {
4293                 if (!strncmp (name, "Vector", 6))
4294                         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");
4295         }
4296
4297         mono_loader_unlock ();
4298
4299         mono_profiler_class_loaded (class, MONO_PROFILE_OK);
4300
4301         return class;
4302 }
4303
4304 /** is klass Nullable<T>? */
4305 gboolean
4306 mono_class_is_nullable (MonoClass *klass)
4307 {
4308        return klass->generic_class != NULL &&
4309                klass->generic_class->container_class == mono_defaults.generic_nullable_class;
4310 }
4311
4312
4313 /** if klass is T? return T */
4314 MonoClass*
4315 mono_class_get_nullable_param (MonoClass *klass)
4316 {
4317        g_assert (mono_class_is_nullable (klass));
4318        return mono_class_from_mono_type (klass->generic_class->context.class_inst->type_argv [0]);
4319 }
4320
4321 /*
4322  * Create the `MonoClass' for an instantiation of a generic type.
4323  * We only do this if we actually need it.
4324  */
4325 MonoClass*
4326 mono_generic_class_get_class (MonoGenericClass *gclass)
4327 {
4328         MonoClass *klass, *gklass;
4329         int i;
4330
4331         mono_loader_lock ();
4332         if (gclass->cached_class) {
4333                 mono_loader_unlock ();
4334                 return gclass->cached_class;
4335         }
4336
4337         gclass->cached_class = g_malloc0 (sizeof (MonoClass));
4338         klass = gclass->cached_class;
4339
4340         gklass = gclass->container_class;
4341
4342         if (gklass->nested_in) {
4343                 /*
4344                  * FIXME: the nested type context should include everything the
4345                  * nesting context should have, but it may also have additional
4346                  * generic parameters...
4347                  */
4348                 MonoType *inflated = mono_class_inflate_generic_type (
4349                         &gklass->nested_in->byval_arg, mono_generic_class_get_context (gclass));
4350                 klass->nested_in = mono_class_from_mono_type (inflated);
4351                 mono_metadata_free_type (inflated);
4352         }
4353
4354         klass->name = gklass->name;
4355         klass->name_space = gklass->name_space;
4356
4357         mono_profiler_class_event (klass, MONO_PROFILE_START_LOAD);
4358
4359         klass->image = gklass->image;
4360         klass->flags = gklass->flags;
4361         klass->type_token = gklass->type_token;
4362         klass->field.count = gklass->field.count;
4363         klass->property.count = gklass->property.count;
4364
4365         klass->generic_class = gclass;
4366
4367         klass->this_arg.type = klass->byval_arg.type = MONO_TYPE_GENERICINST;
4368         klass->this_arg.data.generic_class = klass->byval_arg.data.generic_class = gclass;
4369         klass->this_arg.byref = TRUE;
4370         klass->enumtype = gklass->enumtype;
4371         klass->valuetype = gklass->valuetype;
4372
4373         klass->cast_class = klass->element_class = klass;
4374
4375         if (mono_class_is_nullable (klass))
4376                 klass->cast_class = klass->element_class = mono_class_get_nullable_param (klass);
4377
4378         klass->interface_count = gklass->interface_count;
4379         klass->interfaces = g_new0 (MonoClass *, klass->interface_count);
4380         for (i = 0; i < klass->interface_count; i++) {
4381                 MonoType *it = &gklass->interfaces [i]->byval_arg;
4382                 MonoType *inflated = mono_class_inflate_generic_type (it, mono_generic_class_get_context (gclass));
4383                 klass->interfaces [i] = mono_class_from_mono_type (inflated);
4384                 mono_metadata_free_type (inflated);
4385         }
4386
4387         /*
4388          * We're not interested in the nested classes of a generic instance.
4389          * We use the generic type definition to look for nested classes.
4390          */
4391         klass->nested_classes = NULL;
4392
4393         if (gklass->parent) {
4394                 MonoType *inflated = mono_class_inflate_generic_type (
4395                         &gklass->parent->byval_arg, mono_generic_class_get_context (gclass));
4396
4397                 klass->parent = mono_class_from_mono_type (inflated);
4398                 mono_metadata_free_type (inflated);
4399         }
4400
4401         if (klass->parent)
4402                 mono_class_setup_parent (klass, klass->parent);
4403
4404         if (klass->enumtype) {
4405                 klass->enum_basetype = gklass->enum_basetype;
4406                 klass->cast_class = gklass->cast_class;
4407         }
4408
4409         if (gclass->is_dynamic) {
4410                 klass->inited = 1;
4411
4412                 mono_class_setup_supertypes (klass);
4413
4414                 if (klass->enumtype) {
4415                         /*
4416                          * For enums, gklass->fields might not been set, but instance_size etc. is
4417                          * already set in mono_reflection_create_internal_class (). For non-enums,
4418                          * these will be computed normally in mono_class_layout_fields ().
4419                          */
4420                         klass->instance_size = gklass->instance_size;
4421                         klass->sizes.class_size = gklass->sizes.class_size;
4422                         klass->size_inited = 1;
4423                 }
4424         }
4425
4426         mono_profiler_class_loaded (klass, MONO_PROFILE_OK);
4427
4428         mono_loader_unlock ();
4429
4430         return klass;
4431 }
4432
4433 /*
4434  * LOCKING: Acquires the loader lock.
4435  */
4436 MonoClass *
4437 mono_class_from_generic_parameter (MonoGenericParam *param, MonoImage *image, gboolean is_mvar)
4438 {
4439         MonoClass *klass, **ptr;
4440         int count, pos, i;
4441
4442         mono_loader_lock ();
4443
4444         if (param->pklass) {
4445                 mono_loader_unlock ();
4446                 return param->pklass;
4447         }
4448
4449         if (!image && param->owner) {
4450                 if (is_mvar) {
4451                         MonoMethod *method = param->owner->owner.method;
4452                         image = (method && method->klass) ? method->klass->image : NULL;
4453                 } else {
4454                         MonoClass *klass = param->owner->owner.klass;
4455                         // FIXME: 'klass' should not be null
4456                         //        But, monodis creates GenericContainers without associating a owner to it
4457                         image = klass ? klass->image : NULL;
4458                 }
4459         }
4460         if (!image)
4461                 /* FIXME: */
4462                 image = mono_defaults.corlib;
4463
4464         klass = mono_image_alloc0 (image, sizeof (MonoClass));
4465
4466         if (param->name)
4467                 klass->name = param->name;
4468         else {
4469                 klass->name = mono_image_alloc0 (image, 16);
4470                 sprintf ((char*)klass->name, is_mvar ? "!!%d" : "!%d", param->num);
4471         }
4472         klass->name_space = "";
4473         mono_profiler_class_event (klass, MONO_PROFILE_START_LOAD);
4474
4475         for (count = 0, ptr = param->constraints; ptr && *ptr; ptr++, count++)
4476                 ;
4477
4478         pos = 0;
4479         if ((count > 0) && !MONO_CLASS_IS_INTERFACE (param->constraints [0])) {
4480                 klass->parent = param->constraints [0];
4481                 pos++;
4482         } else if (param->flags & GENERIC_PARAMETER_ATTRIBUTE_VALUE_TYPE_CONSTRAINT)
4483                 klass->parent = mono_class_from_name (mono_defaults.corlib, "System", "ValueType");
4484         else
4485                 klass->parent = mono_defaults.object_class;
4486
4487         if (count - pos > 0) {
4488                 klass->interface_count = count - pos;
4489                 klass->interfaces = mono_image_alloc0 (image, sizeof (MonoClass *) * (count - pos));
4490                 for (i = pos; i < count; i++)
4491                         klass->interfaces [i - pos] = param->constraints [i];
4492         }
4493
4494         if (!image)
4495                 image = mono_defaults.corlib;
4496
4497         klass->image = image;
4498
4499         klass->inited = TRUE;
4500         klass->cast_class = klass->element_class = klass;
4501         klass->enum_basetype = &klass->element_class->byval_arg;
4502         klass->flags = TYPE_ATTRIBUTE_PUBLIC;
4503
4504         klass->this_arg.type = klass->byval_arg.type = is_mvar ? MONO_TYPE_MVAR : MONO_TYPE_VAR;
4505         klass->this_arg.data.generic_param = klass->byval_arg.data.generic_param = param;
4506         klass->this_arg.byref = TRUE;
4507
4508         if (param->owner) {
4509                 guint32 owner;
4510                 guint32 cols [MONO_GENERICPARAM_SIZE];
4511                 MonoTableInfo *tdef  = &image->tables [MONO_TABLE_GENERICPARAM];
4512                 i = 0;
4513
4514                 if (is_mvar && param->owner->owner.method)
4515                          i = mono_metadata_get_generic_param_row (image, param->owner->owner.method->token, &owner);
4516                 else if (!is_mvar && param->owner->owner.klass)
4517                          i = mono_metadata_get_generic_param_row (image, param->owner->owner.klass->type_token, &owner);
4518
4519                 if (i) {
4520                         mono_metadata_decode_row (tdef, i - 1, cols, MONO_GENERICPARAM_SIZE);
4521                         do {
4522                                 if (cols [MONO_GENERICPARAM_NUMBER] == param->num) {
4523                                         klass->sizes.generic_param_token = i | MONO_TOKEN_GENERIC_PARAM;
4524                                         break;
4525                                 }
4526                                 if (++i > tdef->rows)
4527                                         break;
4528                                 mono_metadata_decode_row (tdef, i - 1, cols, MONO_GENERICPARAM_SIZE);
4529                         } while (cols [MONO_GENERICPARAM_OWNER] == owner);
4530                 }
4531         }
4532
4533         mono_class_setup_supertypes (klass);
4534
4535         mono_memory_barrier ();
4536
4537         param->pklass = klass;
4538
4539         mono_loader_unlock ();
4540
4541         mono_profiler_class_loaded (klass, MONO_PROFILE_OK);
4542
4543         return klass;
4544 }
4545
4546 MonoClass *
4547 mono_ptr_class_get (MonoType *type)
4548 {
4549         MonoClass *result;
4550         MonoClass *el_class;
4551         MonoImage *image;
4552         char *name;
4553
4554         el_class = mono_class_from_mono_type (type);
4555         image = el_class->image;
4556
4557         mono_loader_lock ();
4558
4559         if (!image->ptr_cache)
4560                 image->ptr_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
4561
4562         if ((result = g_hash_table_lookup (image->ptr_cache, el_class))) {
4563                 mono_loader_unlock ();
4564                 return result;
4565         }
4566         result = mono_image_alloc0 (image, sizeof (MonoClass));
4567
4568         result->parent = NULL; /* no parent for PTR types */
4569         result->name_space = el_class->name_space;
4570         name = g_strdup_printf ("%s*", el_class->name);
4571         result->name = mono_image_strdup (image, name);
4572         g_free (name);
4573
4574         mono_profiler_class_event (result, MONO_PROFILE_START_LOAD);
4575
4576         result->image = el_class->image;
4577         result->inited = TRUE;
4578         result->flags = TYPE_ATTRIBUTE_CLASS | (el_class->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK);
4579         /* Can pointers get boxed? */
4580         result->instance_size = sizeof (gpointer);
4581         result->cast_class = result->element_class = el_class;
4582         result->enum_basetype = &result->element_class->byval_arg;
4583         result->blittable = TRUE;
4584
4585         result->this_arg.type = result->byval_arg.type = MONO_TYPE_PTR;
4586         result->this_arg.data.type = result->byval_arg.data.type = result->enum_basetype;
4587         result->this_arg.byref = TRUE;
4588
4589         mono_class_setup_supertypes (result);
4590
4591         g_hash_table_insert (image->ptr_cache, el_class, result);
4592
4593         mono_loader_unlock ();
4594
4595         mono_profiler_class_loaded (result, MONO_PROFILE_OK);
4596
4597         return result;
4598 }
4599
4600 static MonoClass *
4601 mono_fnptr_class_get (MonoMethodSignature *sig)
4602 {
4603         MonoClass *result;
4604         static GHashTable *ptr_hash = NULL;
4605
4606         /* FIXME: These should be allocate from a mempool as well, but which one ? */
4607
4608         mono_loader_lock ();
4609
4610         if (!ptr_hash)
4611                 ptr_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
4612
4613         if ((result = g_hash_table_lookup (ptr_hash, sig))) {
4614                 mono_loader_unlock ();
4615                 return result;
4616         }
4617         result = g_new0 (MonoClass, 1);
4618
4619         result->parent = NULL; /* no parent for PTR types */
4620         result->name_space = "System";
4621         result->name = "MonoFNPtrFakeClass";
4622
4623         mono_profiler_class_event (result, MONO_PROFILE_START_LOAD);
4624
4625         result->image = mono_defaults.corlib; /* need to fix... */
4626         result->inited = TRUE;
4627         result->flags = TYPE_ATTRIBUTE_CLASS; /* | (el_class->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK); */
4628         /* Can pointers get boxed? */
4629         result->instance_size = sizeof (gpointer);
4630         result->cast_class = result->element_class = result;
4631         result->blittable = TRUE;
4632
4633         result->this_arg.type = result->byval_arg.type = MONO_TYPE_FNPTR;
4634         result->this_arg.data.method = result->byval_arg.data.method = sig;
4635         result->this_arg.byref = TRUE;
4636         result->enum_basetype = &result->element_class->byval_arg;
4637         result->blittable = TRUE;
4638
4639         mono_class_setup_supertypes (result);
4640
4641         g_hash_table_insert (ptr_hash, sig, result);
4642
4643         mono_loader_unlock ();
4644
4645         mono_profiler_class_loaded (result, MONO_PROFILE_OK);
4646
4647         return result;
4648 }
4649
4650 MonoClass *
4651 mono_class_from_mono_type (MonoType *type)
4652 {
4653         switch (type->type) {
4654         case MONO_TYPE_OBJECT:
4655                 return type->data.klass? type->data.klass: mono_defaults.object_class;
4656         case MONO_TYPE_VOID:
4657                 return type->data.klass? type->data.klass: mono_defaults.void_class;
4658         case MONO_TYPE_BOOLEAN:
4659                 return type->data.klass? type->data.klass: mono_defaults.boolean_class;
4660         case MONO_TYPE_CHAR:
4661                 return type->data.klass? type->data.klass: mono_defaults.char_class;
4662         case MONO_TYPE_I1:
4663                 return type->data.klass? type->data.klass: mono_defaults.sbyte_class;
4664         case MONO_TYPE_U1:
4665                 return type->data.klass? type->data.klass: mono_defaults.byte_class;
4666         case MONO_TYPE_I2:
4667                 return type->data.klass? type->data.klass: mono_defaults.int16_class;
4668         case MONO_TYPE_U2:
4669                 return type->data.klass? type->data.klass: mono_defaults.uint16_class;
4670         case MONO_TYPE_I4:
4671                 return type->data.klass? type->data.klass: mono_defaults.int32_class;
4672         case MONO_TYPE_U4:
4673                 return type->data.klass? type->data.klass: mono_defaults.uint32_class;
4674         case MONO_TYPE_I:
4675                 return type->data.klass? type->data.klass: mono_defaults.int_class;
4676         case MONO_TYPE_U:
4677                 return type->data.klass? type->data.klass: mono_defaults.uint_class;
4678         case MONO_TYPE_I8:
4679                 return type->data.klass? type->data.klass: mono_defaults.int64_class;
4680         case MONO_TYPE_U8:
4681                 return type->data.klass? type->data.klass: mono_defaults.uint64_class;
4682         case MONO_TYPE_R4:
4683                 return type->data.klass? type->data.klass: mono_defaults.single_class;
4684         case MONO_TYPE_R8:
4685                 return type->data.klass? type->data.klass: mono_defaults.double_class;
4686         case MONO_TYPE_STRING:
4687                 return type->data.klass? type->data.klass: mono_defaults.string_class;
4688         case MONO_TYPE_TYPEDBYREF:
4689                 return type->data.klass? type->data.klass: mono_defaults.typed_reference_class;
4690         case MONO_TYPE_ARRAY:
4691                 return mono_bounded_array_class_get (type->data.array->eklass, type->data.array->rank, TRUE);
4692         case MONO_TYPE_PTR:
4693                 return mono_ptr_class_get (type->data.type);
4694         case MONO_TYPE_FNPTR:
4695                 return mono_fnptr_class_get (type->data.method);
4696         case MONO_TYPE_SZARRAY:
4697                 return mono_array_class_get (type->data.klass, 1);
4698         case MONO_TYPE_CLASS:
4699         case MONO_TYPE_VALUETYPE:
4700                 return type->data.klass;
4701         case MONO_TYPE_GENERICINST:
4702                 return mono_generic_class_get_class (type->data.generic_class);
4703         case MONO_TYPE_VAR:
4704                 return mono_class_from_generic_parameter (type->data.generic_param, NULL, FALSE);
4705         case MONO_TYPE_MVAR:
4706                 return mono_class_from_generic_parameter (type->data.generic_param, NULL, TRUE);
4707         default:
4708                 g_warning ("mono_class_from_mono_type: implement me 0x%02x\n", type->type);
4709                 g_assert_not_reached ();
4710         }
4711
4712         return NULL;
4713 }
4714
4715 /**
4716  * mono_type_retrieve_from_typespec
4717  * @image: context where the image is created
4718  * @type_spec:  typespec token
4719  * @context: the generic context used to evaluate generic instantiations in
4720  */
4721 static MonoType *
4722 mono_type_retrieve_from_typespec (MonoImage *image, guint32 type_spec, MonoGenericContext *context, gboolean *did_inflate)
4723 {
4724         MonoType *t = mono_type_create_from_typespec (image, type_spec);
4725         if (!t)
4726                 return NULL;
4727         if (context && (context->class_inst || context->method_inst)) {
4728                 MonoType *inflated = inflate_generic_type (NULL, t, context);
4729                 if (inflated) {
4730                         t = inflated;
4731                         *did_inflate = TRUE;
4732                 }
4733         }
4734         return t;
4735 }
4736
4737 /**
4738  * mono_class_create_from_typespec
4739  * @image: context where the image is created
4740  * @type_spec:  typespec token
4741  * @context: the generic context used to evaluate generic instantiations in
4742  */
4743 static MonoClass *
4744 mono_class_create_from_typespec (MonoImage *image, guint32 type_spec, MonoGenericContext *context)
4745 {
4746         MonoClass *ret;
4747         gboolean inflated = FALSE;
4748         MonoType *t = mono_type_retrieve_from_typespec (image, type_spec, context, &inflated);
4749         if (!t)
4750                 return NULL;
4751         ret = mono_class_from_mono_type (t);
4752         if (inflated)
4753                 mono_metadata_free_type (t);
4754         return ret;
4755 }
4756
4757 /**
4758  * mono_bounded_array_class_get:
4759  * @element_class: element class
4760  * @rank: the dimension of the array class
4761  * @bounded: whenever the array has non-zero bounds
4762  *
4763  * Returns: a class object describing the array with element type @element_type and
4764  * dimension @rank.
4765  */
4766 MonoClass *
4767 mono_bounded_array_class_get (MonoClass *eclass, guint32 rank, gboolean bounded)
4768 {
4769         MonoImage *image;
4770         MonoClass *class;
4771         MonoClass *parent = NULL;
4772         GSList *list, *rootlist;
4773         int nsize;
4774         char *name;
4775         gboolean corlib_type = FALSE;
4776
4777         g_assert (rank <= 255);
4778
4779         if (rank > 1)
4780                 /* bounded only matters for one-dimensional arrays */
4781                 bounded = FALSE;
4782
4783         image = eclass->image;
4784
4785         mono_loader_lock ();
4786
4787         if (!image->array_cache)
4788                 image->array_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
4789
4790         if ((rootlist = list = g_hash_table_lookup (image->array_cache, eclass))) {
4791                 for (; list; list = list->next) {
4792                         class = list->data;
4793                         if ((class->rank == rank) && (class->byval_arg.type == (((rank > 1) || bounded) ? MONO_TYPE_ARRAY : MONO_TYPE_SZARRAY))) {
4794                                 mono_loader_unlock ();
4795                                 return class;
4796                         }
4797                 }
4798         }
4799
4800         /* for the building corlib use System.Array from it */
4801         if (image->assembly && image->assembly->dynamic && image->assembly_name && strcmp (image->assembly_name, "mscorlib") == 0) {
4802                 parent = mono_class_from_name (image, "System", "Array");
4803                 corlib_type = TRUE;
4804         } else {
4805                 parent = mono_defaults.array_class;
4806                 if (!parent->inited)
4807                         mono_class_init (parent);
4808         }
4809
4810         class = mono_image_alloc0 (image, sizeof (MonoClass));
4811
4812         class->image = image;
4813         class->name_space = eclass->name_space;
4814         nsize = strlen (eclass->name);
4815         name = g_malloc (nsize + 2 + rank + 1);
4816         memcpy (name, eclass->name, nsize);
4817         name [nsize] = '[';
4818         if (rank > 1)
4819                 memset (name + nsize + 1, ',', rank - 1);
4820         if (bounded)
4821                 name [nsize + rank] = '*';
4822         name [nsize + rank + bounded] = ']';
4823         name [nsize + rank + bounded + 1] = 0;
4824         class->name = mono_image_strdup (image, name);
4825         g_free (name);
4826
4827         mono_profiler_class_event (class, MONO_PROFILE_START_LOAD);
4828
4829         class->type_token = 0;
4830         /* all arrays are marked serializable and sealed, bug #42779 */
4831         class->flags = TYPE_ATTRIBUTE_CLASS | TYPE_ATTRIBUTE_SERIALIZABLE | TYPE_ATTRIBUTE_SEALED |
4832                 (eclass->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK);
4833         class->parent = parent;
4834         class->instance_size = mono_class_instance_size (class->parent);
4835
4836         if (eclass->enumtype && !eclass->enum_basetype) {
4837                 if (!eclass->reflection_info || eclass->wastypebuilder) {
4838                         g_warning ("Only incomplete TypeBuilder objects are allowed to be an enum without base_type");
4839                         g_assert (eclass->reflection_info && !eclass->wastypebuilder);
4840                 }
4841                 /* element_size -1 is ok as this is not an instantitable type*/
4842                 class->sizes.element_size = -1;
4843         } else
4844                 class->sizes.element_size = mono_class_array_element_size (eclass);
4845
4846         mono_class_setup_supertypes (class);
4847
4848         if (mono_defaults.generic_ilist_class && !bounded && rank == 1) {
4849                 MonoType *args [1];
4850
4851                 /* generic IList, ICollection, IEnumerable */
4852                 class->interface_count = 1;
4853                 class->interfaces = mono_image_alloc0 (image, sizeof (MonoClass*) * class->interface_count);
4854
4855                 args [0] = &eclass->byval_arg;
4856                 class->interfaces [0] = mono_class_bind_generic_parameters (
4857                         mono_defaults.generic_ilist_class, 1, args, FALSE);
4858         }
4859
4860         if (eclass->generic_class)
4861                 mono_class_init (eclass);
4862         if (!eclass->size_inited)
4863                 mono_class_setup_fields (eclass);
4864         class->has_references = MONO_TYPE_IS_REFERENCE (&eclass->byval_arg) || eclass->has_references? TRUE: FALSE;
4865
4866         class->rank = rank;
4867
4868         if (eclass->enumtype)
4869                 class->cast_class = eclass->element_class;
4870         else
4871                 class->cast_class = eclass;
4872
4873         class->element_class = eclass;
4874
4875         if ((rank > 1) || bounded) {
4876                 MonoArrayType *at = mono_image_alloc0 (image, sizeof (MonoArrayType));
4877                 class->byval_arg.type = MONO_TYPE_ARRAY;
4878                 class->byval_arg.data.array = at;
4879                 at->eklass = eclass;
4880                 at->rank = rank;
4881                 /* FIXME: complete.... */
4882         } else {
4883                 class->byval_arg.type = MONO_TYPE_SZARRAY;
4884                 class->byval_arg.data.klass = eclass;
4885         }
4886         class->this_arg = class->byval_arg;
4887         class->this_arg.byref = 1;
4888         if (corlib_type) {
4889                 class->inited = 1;
4890         }
4891
4892         class->generic_container = eclass->generic_container;
4893
4894         list = g_slist_append (rootlist, class);
4895         g_hash_table_insert (image->array_cache, eclass, list);
4896
4897         mono_loader_unlock ();
4898
4899         mono_profiler_class_loaded (class, MONO_PROFILE_OK);
4900
4901         return class;
4902 }
4903
4904 /**
4905  * mono_array_class_get:
4906  * @element_class: element class
4907  * @rank: the dimension of the array class
4908  *
4909  * Returns: a class object describing the array with element type @element_type and
4910  * dimension @rank.
4911  */
4912 MonoClass *
4913 mono_array_class_get (MonoClass *eclass, guint32 rank)
4914 {
4915         return mono_bounded_array_class_get (eclass, rank, FALSE);
4916 }
4917
4918 /**
4919  * mono_class_instance_size:
4920  * @klass: a class
4921  *
4922  * Returns: the size of an object instance
4923  */
4924 gint32
4925 mono_class_instance_size (MonoClass *klass)
4926 {
4927         if (!klass->size_inited)
4928                 mono_class_init (klass);
4929
4930         return klass->instance_size;
4931 }
4932
4933 /**
4934  * mono_class_min_align:
4935  * @klass: a class
4936  *
4937  * Returns: minimm alignment requirements
4938  */
4939 gint32
4940 mono_class_min_align (MonoClass *klass)
4941 {
4942         if (!klass->size_inited)
4943                 mono_class_init (klass);
4944
4945         return klass->min_align;
4946 }
4947
4948 /**
4949  * mono_class_value_size:
4950  * @klass: a class
4951  *
4952  * This function is used for value types, and return the
4953  * space and the alignment to store that kind of value object.
4954  *
4955  * Returns: the size of a value of kind @klass
4956  */
4957 gint32
4958 mono_class_value_size      (MonoClass *klass, guint32 *align)
4959 {
4960         gint32 size;
4961
4962         /* fixme: check disable, because we still have external revereces to
4963          * mscorlib and Dummy Objects
4964          */
4965         /*g_assert (klass->valuetype);*/
4966
4967         size = mono_class_instance_size (klass) - sizeof (MonoObject);
4968
4969         if (align)
4970                 *align = klass->min_align;
4971
4972         return size;
4973 }
4974
4975 /**
4976  * mono_class_data_size:
4977  * @klass: a class
4978  *
4979  * Returns: the size of the static class data
4980  */
4981 gint32
4982 mono_class_data_size (MonoClass *klass)
4983 {
4984         if (!klass->inited)
4985                 mono_class_init (klass);
4986
4987         /* in arrays, sizes.class_size is unioned with element_size
4988          * and arrays have no static fields
4989          */
4990         if (klass->rank)
4991                 return 0;
4992         return klass->sizes.class_size;
4993 }
4994
4995 /*
4996  * Auxiliary routine to mono_class_get_field
4997  *
4998  * Takes a field index instead of a field token.
4999  */
5000 static MonoClassField *
5001 mono_class_get_field_idx (MonoClass *class, int idx)
5002 {
5003         mono_class_setup_fields_locking (class);
5004
5005         while (class) {
5006                 if (class->image->uncompressed_metadata) {
5007                         /*
5008                          * class->field.first points to the FieldPtr table, while idx points into the
5009                          * Field table, so we have to do a search.
5010                          */
5011                         const char *name = mono_metadata_string_heap (class->image, mono_metadata_decode_row_col (&class->image->tables [MONO_TABLE_FIELD], idx, MONO_FIELD_NAME));
5012                         int i;
5013
5014                         for (i = 0; i < class->field.count; ++i)
5015                                 if (mono_field_get_name (&class->fields [i]) == name)
5016                                         return &class->fields [i];
5017                         g_assert_not_reached ();
5018                 } else {
5019                         if (class->field.count) {
5020                                 if ((idx >= class->field.first) && (idx < class->field.first + class->field.count)){
5021                                         return &class->fields [idx - class->field.first];
5022                                 }
5023                         }
5024                 }
5025                 class = class->parent;
5026         }
5027         return NULL;
5028 }
5029
5030 /**
5031  * mono_class_get_field:
5032  * @class: the class to lookup the field.
5033  * @field_token: the field token
5034  *
5035  * Returns: A MonoClassField representing the type and offset of
5036  * the field, or a NULL value if the field does not belong to this
5037  * class.
5038  */
5039 MonoClassField *
5040 mono_class_get_field (MonoClass *class, guint32 field_token)
5041 {
5042         int idx = mono_metadata_token_index (field_token);
5043
5044         g_assert (mono_metadata_token_code (field_token) == MONO_TOKEN_FIELD_DEF);
5045
5046         return mono_class_get_field_idx (class, idx - 1);
5047 }
5048
5049 /**
5050  * mono_class_get_field_from_name:
5051  * @klass: the class to lookup the field.
5052  * @name: the field name
5053  *
5054  * Search the class @klass and it's parents for a field with the name @name.
5055  *
5056  * Returns: the MonoClassField pointer of the named field or NULL
5057  */
5058 MonoClassField *
5059 mono_class_get_field_from_name (MonoClass *klass, const char *name)
5060 {
5061         int i;
5062
5063         mono_class_setup_fields_locking (klass);
5064         while (klass) {
5065                 for (i = 0; i < klass->field.count; ++i) {
5066                         if (strcmp (name, mono_field_get_name (&klass->fields [i])) == 0)
5067                                 return &klass->fields [i];
5068                 }
5069                 klass = klass->parent;
5070         }
5071         return NULL;
5072 }
5073
5074 /**
5075  * mono_class_get_field_token:
5076  * @field: the field we need the token of
5077  *
5078  * Get the token of a field. Note that the tokesn is only valid for the image
5079  * the field was loaded from. Don't use this function for fields in dynamic types.
5080  *
5081  * Returns: the token representing the field in the image it was loaded from.
5082  */
5083 guint32
5084 mono_class_get_field_token (MonoClassField *field)
5085 {
5086         MonoClass *klass = field->parent;
5087         int i;
5088
5089         mono_class_setup_fields_locking (klass);
5090         while (klass) {
5091                 for (i = 0; i < klass->field.count; ++i) {
5092                         if (&klass->fields [i] == field) {
5093                                 int idx = klass->field.first + i + 1;
5094
5095                                 if (klass->image->uncompressed_metadata)
5096                                         idx = mono_metadata_translate_token_index (klass->image, MONO_TABLE_FIELD, idx);
5097                                 return mono_metadata_make_token (MONO_TABLE_FIELD, idx);
5098                         }
5099                 }
5100                 klass = klass->parent;
5101         }
5102
5103         g_assert_not_reached ();
5104         return 0;
5105 }
5106
5107 static int
5108 mono_field_get_index (MonoClassField *field)
5109 {
5110         int index = field - field->parent->fields;
5111
5112         g_assert (index >= 0 && index < field->parent->field.count);
5113
5114         return index;
5115 }
5116
5117 /*
5118  * mono_class_get_field_default_value:
5119  *
5120  * Return the default value of the field as a pointer into the metadata blob.
5121  */
5122 const char*
5123 mono_class_get_field_default_value (MonoClassField *field, MonoTypeEnum *def_type)
5124 {
5125         guint32 cindex;
5126         guint32 constant_cols [MONO_CONSTANT_SIZE];
5127         int field_index;
5128         MonoClass *klass = field->parent;
5129
5130         g_assert (field->type->attrs & FIELD_ATTRIBUTE_HAS_DEFAULT);
5131
5132         if (!klass->field_def_values) {
5133                 mono_loader_lock ();
5134                 if (!klass->field_def_values)
5135                         klass->field_def_values = mono_image_alloc0 (klass->image, sizeof (MonoFieldDefaultValue) * klass->field.count);
5136                 mono_loader_unlock ();
5137         }
5138
5139         field_index = mono_field_get_index (field);
5140
5141         if (!klass->field_def_values [field_index].data) {
5142                 cindex = mono_metadata_get_constant_index (field->parent->image, mono_class_get_field_token (field), 0);
5143                 g_assert (cindex);
5144                 g_assert (!(field->type->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA));
5145
5146                 mono_metadata_decode_row (&field->parent->image->tables [MONO_TABLE_CONSTANT], cindex - 1, constant_cols, MONO_CONSTANT_SIZE);
5147                 klass->field_def_values [field_index].def_type = constant_cols [MONO_CONSTANT_TYPE];
5148                 klass->field_def_values [field_index].data = (gpointer)mono_metadata_blob_heap (field->parent->image, constant_cols [MONO_CONSTANT_VALUE]);
5149         }
5150
5151         *def_type = klass->field_def_values [field_index].def_type;
5152         return klass->field_def_values [field_index].data;
5153 }
5154
5155 guint32
5156 mono_class_get_event_token (MonoEvent *event)
5157 {
5158         MonoClass *klass = event->parent;
5159         int i;
5160
5161         while (klass) {
5162                 for (i = 0; i < klass->event.count; ++i) {
5163                         if (&klass->events [i] == event)
5164                                 return mono_metadata_make_token (MONO_TABLE_EVENT, klass->event.first + i + 1);
5165                 }
5166                 klass = klass->parent;
5167         }
5168
5169         g_assert_not_reached ();
5170         return 0;
5171 }
5172
5173 MonoProperty*
5174 mono_class_get_property_from_name (MonoClass *klass, const char *name)
5175 {
5176         while (klass) {
5177                 MonoProperty* p;
5178                 gpointer iter = NULL;
5179                 while ((p = mono_class_get_properties (klass, &iter))) {
5180                         if (! strcmp (name, p->name))
5181                                 return p;
5182                 }
5183                 klass = klass->parent;
5184         }
5185         return NULL;
5186 }
5187
5188 guint32
5189 mono_class_get_property_token (MonoProperty *prop)
5190 {
5191         MonoClass *klass = prop->parent;
5192         while (klass) {
5193                 MonoProperty* p;
5194                 int i = 0;
5195                 gpointer iter = NULL;
5196                 while ((p = mono_class_get_properties (klass, &iter))) {
5197                         if (&klass->properties [i] == prop)
5198                                 return mono_metadata_make_token (MONO_TABLE_PROPERTY, klass->property.first + i + 1);
5199
5200                         i ++;
5201                 }
5202                 klass = klass->parent;
5203         }
5204
5205         g_assert_not_reached ();
5206         return 0;
5207 }
5208
5209 char *
5210 mono_class_name_from_token (MonoImage *image, guint32 type_token)
5211 {
5212         const char *name, *nspace;
5213         if (image->dynamic)
5214                 return g_strdup_printf ("DynamicType 0x%08x", type_token);
5215
5216         switch (type_token & 0xff000000){
5217         case MONO_TOKEN_TYPE_DEF: {
5218                 guint32 cols [MONO_TYPEDEF_SIZE];
5219                 MonoTableInfo *tt = &image->tables [MONO_TABLE_TYPEDEF];
5220                 guint tidx = mono_metadata_token_index (type_token);
5221
5222                 mono_metadata_decode_row (tt, tidx - 1, cols, MONO_TYPEDEF_SIZE);
5223                 name = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAME]);
5224                 nspace = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAMESPACE]);
5225                 if (strlen (nspace) == 0)
5226                         return g_strdup_printf ("%s", name);
5227                 else
5228                         return g_strdup_printf ("%s.%s", nspace, name);
5229         }
5230
5231         case MONO_TOKEN_TYPE_REF: {
5232                 guint32 cols [MONO_TYPEREF_SIZE];
5233                 MonoTableInfo  *t = &image->tables [MONO_TABLE_TYPEREF];
5234
5235                 mono_metadata_decode_row (t, (type_token&0xffffff)-1, cols, MONO_TYPEREF_SIZE);
5236                 name = mono_metadata_string_heap (image, cols [MONO_TYPEREF_NAME]);
5237                 nspace = mono_metadata_string_heap (image, cols [MONO_TYPEREF_NAMESPACE]);
5238                 if (strlen (nspace) == 0)
5239                         return g_strdup_printf ("%s", name);
5240                 else
5241                         return g_strdup_printf ("%s.%s", nspace, name);
5242         }
5243
5244         case MONO_TOKEN_TYPE_SPEC:
5245                 return g_strdup_printf ("Typespec 0x%08x", type_token);
5246         default:
5247                 g_assert_not_reached ();
5248         }
5249
5250         return NULL;
5251 }
5252
5253 static char *
5254 mono_assembly_name_from_token (MonoImage *image, guint32 type_token)
5255 {
5256         if (image->dynamic)
5257                 return g_strdup_printf ("DynamicAssembly %s", image->name);
5258
5259         switch (type_token & 0xff000000){
5260         case MONO_TOKEN_TYPE_DEF:
5261                 return mono_stringify_assembly_name (&image->assembly->aname);
5262                 break;
5263         case MONO_TOKEN_TYPE_REF: {
5264                 MonoAssemblyName aname;
5265                 guint32 cols [MONO_TYPEREF_SIZE];
5266                 MonoTableInfo  *t = &image->tables [MONO_TABLE_TYPEREF];
5267                 guint32 idx;
5268
5269                 mono_metadata_decode_row (t, (type_token&0xffffff)-1, cols, MONO_TYPEREF_SIZE);
5270
5271                 idx = cols [MONO_TYPEREF_SCOPE] >> MONO_RESOLTION_SCOPE_BITS;
5272                 switch (cols [MONO_TYPEREF_SCOPE] & MONO_RESOLTION_SCOPE_MASK) {
5273                 case MONO_RESOLTION_SCOPE_MODULE:
5274                         /* FIXME: */
5275                         return g_strdup ("");
5276                 case MONO_RESOLTION_SCOPE_MODULEREF:
5277                         /* FIXME: */
5278                         return g_strdup ("");
5279                 case MONO_RESOLTION_SCOPE_TYPEREF:
5280                         /* FIXME: */
5281                         return g_strdup ("");
5282                 case MONO_RESOLTION_SCOPE_ASSEMBLYREF:
5283                         mono_assembly_get_assemblyref (image, idx - 1, &aname);
5284                         return mono_stringify_assembly_name (&aname);
5285                 default:
5286                         g_assert_not_reached ();
5287                 }
5288                 break;
5289         }
5290         case MONO_TOKEN_TYPE_SPEC:
5291                 /* FIXME: */
5292                 return g_strdup ("");
5293         default:
5294                 g_assert_not_reached ();
5295         }
5296
5297         return NULL;
5298 }
5299
5300 /**
5301  * mono_class_get_full:
5302  * @image: the image where the class resides
5303  * @type_token: the token for the class
5304  * @context: the generic context used to evaluate generic instantiations in
5305  *
5306  * Returns: the MonoClass that represents @type_token in @image
5307  */
5308 MonoClass *
5309 mono_class_get_full (MonoImage *image, guint32 type_token, MonoGenericContext *context)
5310 {
5311         MonoClass *class = NULL;
5312
5313         if (image->dynamic) {
5314                 int table = mono_metadata_token_table (type_token);
5315
5316                 if (table != MONO_TABLE_TYPEDEF && table != MONO_TABLE_TYPEREF && table != MONO_TABLE_TYPESPEC) {
5317                         mono_loader_set_error_bad_image (g_strdup ("Bad type token."));
5318                         return NULL;
5319                 }
5320                 return mono_lookup_dynamic_token (image, type_token, context);
5321         }
5322
5323         switch (type_token & 0xff000000){
5324         case MONO_TOKEN_TYPE_DEF:
5325                 class = mono_class_create_from_typedef (image, type_token);
5326                 break;
5327         case MONO_TOKEN_TYPE_REF:
5328                 class = mono_class_from_typeref (image, type_token);
5329                 break;
5330         case MONO_TOKEN_TYPE_SPEC:
5331                 class = mono_class_create_from_typespec (image, type_token, context);
5332                 break;
5333         default:
5334                 g_warning ("unknown token type %x", type_token & 0xff000000);
5335                 g_assert_not_reached ();
5336         }
5337
5338         if (!class){
5339                 char *name = mono_class_name_from_token (image, type_token);
5340                 char *assembly = mono_assembly_name_from_token (image, type_token);
5341                 mono_loader_set_error_type_load (name, assembly);
5342         }
5343
5344         return class;
5345 }
5346
5347
5348 /**
5349  * mono_type_get_full:
5350  * @image: the image where the type resides
5351  * @type_token: the token for the type
5352  * @context: the generic context used to evaluate generic instantiations in
5353  *
5354  * This functions exists to fullfill the fact that sometimes it's desirable to have access to the
5355  *
5356  * Returns: the MonoType that represents @type_token in @image
5357  */
5358 MonoType *
5359 mono_type_get_full (MonoImage *image, guint32 type_token, MonoGenericContext *context)
5360 {
5361         MonoType *type = NULL;
5362         gboolean inflated = FALSE;
5363
5364         //FIXME: this will not fix the very issue for which mono_type_get_full exists -but how to do it then?
5365         if (image->dynamic)
5366                 return mono_class_get_type (mono_lookup_dynamic_token (image, type_token, context));
5367
5368         if ((type_token & 0xff000000) != MONO_TOKEN_TYPE_SPEC) {
5369                 MonoClass *class = mono_class_get_full (image, type_token, context);
5370                 return class ? mono_class_get_type (class) : NULL;
5371         }
5372
5373         type = mono_type_retrieve_from_typespec (image, type_token, context, &inflated);
5374
5375         if (!type) {
5376                 char *name = mono_class_name_from_token (image, type_token);
5377                 char *assembly = mono_assembly_name_from_token (image, type_token);
5378                 if (inflated)
5379                         mono_metadata_free_type (type);
5380                 mono_loader_set_error_type_load (name, assembly);
5381         }
5382
5383         if (inflated) {
5384                 MonoType *tmp = type;
5385                 type = mono_class_get_type (mono_class_from_mono_type (type));
5386                 /* FIXME: This is a workaround fo the fact that a typespec token sometimes reference to the generic type definition.
5387                  * A MonoClass::byval_arg of a generic type definion has type CLASS.
5388                  * Some parts of mono create a GENERICINST to reference a generic type definition and this generates confict with byval_arg.
5389                  *
5390                  * The long term solution is to chaise this places and make then set MonoType::type correctly.
5391                  * */
5392                 if (type->type != tmp->type)
5393                         type = tmp;
5394                 else
5395                         mono_metadata_free_type (tmp);
5396         }
5397         return type;
5398 }
5399
5400
5401 MonoClass *
5402 mono_class_get (MonoImage *image, guint32 type_token)
5403 {
5404         return mono_class_get_full (image, type_token, NULL);
5405 }
5406
5407 /**
5408  * mono_image_init_name_cache:
5409  *
5410  *  Initializes the class name cache stored in image->name_cache.
5411  *
5412  * LOCKING: Acquires the loader lock.
5413  */
5414 void
5415 mono_image_init_name_cache (MonoImage *image)
5416 {
5417         MonoTableInfo  *t = &image->tables [MONO_TABLE_TYPEDEF];
5418         guint32 cols [MONO_TYPEDEF_SIZE];
5419         const char *name;
5420         const char *nspace;
5421         guint32 i, visib, nspace_index;
5422         GHashTable *name_cache2, *nspace_table;
5423
5424         mono_loader_lock ();
5425
5426         image->name_cache = g_hash_table_new (g_str_hash, g_str_equal);
5427
5428         if (image->dynamic) {
5429                 mono_loader_unlock ();
5430                 return;
5431         }
5432
5433         /* Temporary hash table to avoid lookups in the nspace_table */
5434         name_cache2 = g_hash_table_new (NULL, NULL);
5435
5436         for (i = 1; i <= t->rows; ++i) {
5437                 mono_metadata_decode_row (t, i - 1, cols, MONO_TYPEDEF_SIZE);
5438                 visib = cols [MONO_TYPEDEF_FLAGS] & TYPE_ATTRIBUTE_VISIBILITY_MASK;
5439                 /*
5440                  * Nested types are accessed from the nesting name.  We use the fact that nested types use different visibility flags
5441                  * than toplevel types, thus avoiding the need to grovel through the NESTED_TYPE table
5442                  */
5443                 if (visib >= TYPE_ATTRIBUTE_NESTED_PUBLIC && visib <= TYPE_ATTRIBUTE_NESTED_FAM_OR_ASSEM)
5444                         continue;
5445                 name = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAME]);
5446                 nspace = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAMESPACE]);
5447
5448                 nspace_index = cols [MONO_TYPEDEF_NAMESPACE];
5449                 nspace_table = g_hash_table_lookup (name_cache2, GUINT_TO_POINTER (nspace_index));
5450                 if (!nspace_table) {
5451                         nspace_table = g_hash_table_new (g_str_hash, g_str_equal);
5452                         g_hash_table_insert (image->name_cache, (char*)nspace, nspace_table);
5453                         g_hash_table_insert (name_cache2, GUINT_TO_POINTER (nspace_index),
5454                                                                  nspace_table);
5455                 }
5456                 g_hash_table_insert (nspace_table, (char *) name, GUINT_TO_POINTER (i));
5457         }
5458
5459         /* Load type names from EXPORTEDTYPES table */
5460         {
5461                 MonoTableInfo  *t = &image->tables [MONO_TABLE_EXPORTEDTYPE];
5462                 guint32 cols [MONO_EXP_TYPE_SIZE];
5463                 int i;
5464
5465                 for (i = 0; i < t->rows; ++i) {
5466                         mono_metadata_decode_row (t, i, cols, MONO_EXP_TYPE_SIZE);
5467                         name = mono_metadata_string_heap (image, cols [MONO_EXP_TYPE_NAME]);
5468                         nspace = mono_metadata_string_heap (image, cols [MONO_EXP_TYPE_NAMESPACE]);
5469
5470                         nspace_index = cols [MONO_EXP_TYPE_NAMESPACE];
5471                         nspace_table = g_hash_table_lookup (name_cache2, GUINT_TO_POINTER (nspace_index));
5472                         if (!nspace_table) {
5473                                 nspace_table = g_hash_table_new (g_str_hash, g_str_equal);
5474                                 g_hash_table_insert (image->name_cache, (char*)nspace, nspace_table);
5475                                 g_hash_table_insert (name_cache2, GUINT_TO_POINTER (nspace_index),
5476                                                                          nspace_table);
5477                         }
5478                         g_hash_table_insert (nspace_table, (char *) name, GUINT_TO_POINTER (mono_metadata_make_token (MONO_TABLE_EXPORTEDTYPE, i + 1)));
5479                 }
5480         }
5481
5482         g_hash_table_destroy (name_cache2);
5483
5484         mono_loader_unlock ();
5485 }
5486
5487 void
5488 mono_image_add_to_name_cache (MonoImage *image, const char *nspace,
5489                                                           const char *name, guint32 index)
5490 {
5491         GHashTable *nspace_table;
5492         GHashTable *name_cache;
5493
5494         mono_loader_lock ();
5495
5496         if (!image->name_cache)
5497                 mono_image_init_name_cache (image);
5498
5499         name_cache = image->name_cache;
5500         if (!(nspace_table = g_hash_table_lookup (name_cache, nspace))) {
5501                 nspace_table = g_hash_table_new (g_str_hash, g_str_equal);
5502                 g_hash_table_insert (name_cache, (char *)nspace, (char *)nspace_table);
5503         }
5504         g_hash_table_insert (nspace_table, (char *) name, GUINT_TO_POINTER (index));
5505
5506         mono_loader_unlock ();
5507 }
5508
5509 typedef struct {
5510         gconstpointer key;
5511         gpointer value;
5512 } FindUserData;
5513
5514 static void
5515 find_nocase (gpointer key, gpointer value, gpointer user_data)
5516 {
5517         char *name = (char*)key;
5518         FindUserData *data = (FindUserData*)user_data;
5519
5520         if (!data->value && (g_strcasecmp (name, (char*)data->key) == 0))
5521                 data->value = value;
5522 }
5523
5524 /**
5525  * mono_class_from_name_case:
5526  * @image: The MonoImage where the type is looked up in
5527  * @name_space: the type namespace
5528  * @name: the type short name.
5529  *
5530  * Obtains a MonoClass with a given namespace and a given name which
5531  * is located in the given MonoImage.   The namespace and name
5532  * lookups are case insensitive.
5533  */
5534 MonoClass *
5535 mono_class_from_name_case (MonoImage *image, const char* name_space, const char *name)
5536 {
5537         MonoTableInfo  *t = &image->tables [MONO_TABLE_TYPEDEF];
5538         guint32 cols [MONO_TYPEDEF_SIZE];
5539         const char *n;
5540         const char *nspace;
5541         guint32 i, visib;
5542
5543         if (image->dynamic) {
5544                 guint32 token = 0;
5545                 FindUserData user_data;
5546
5547                 mono_loader_lock ();
5548
5549                 if (!image->name_cache)
5550                         mono_image_init_name_cache (image);
5551
5552                 user_data.key = name_space;
5553                 user_data.value = NULL;
5554                 g_hash_table_foreach (image->name_cache, find_nocase, &user_data);
5555
5556                 if (user_data.value) {
5557                         GHashTable *nspace_table = (GHashTable*)user_data.value;
5558
5559                         user_data.key = name;
5560                         user_data.value = NULL;
5561
5562                         g_hash_table_foreach (nspace_table, find_nocase, &user_data);
5563
5564                         if (user_data.value)
5565                                 token = GPOINTER_TO_UINT (user_data.value);
5566                 }
5567
5568                 mono_loader_unlock ();
5569
5570                 if (token)
5571                         return mono_class_get (image, MONO_TOKEN_TYPE_DEF | token);
5572                 else
5573                         return NULL;
5574
5575         }
5576
5577         /* add a cache if needed */
5578         for (i = 1; i <= t->rows; ++i) {
5579                 mono_metadata_decode_row (t, i - 1, cols, MONO_TYPEDEF_SIZE);
5580                 visib = cols [MONO_TYPEDEF_FLAGS] & TYPE_ATTRIBUTE_VISIBILITY_MASK;
5581                 /*
5582                  * Nested types are accessed from the nesting name.  We use the fact that nested types use different visibility flags
5583                  * than toplevel types, thus avoiding the need to grovel through the NESTED_TYPE table
5584                  */
5585                 if (visib >= TYPE_ATTRIBUTE_NESTED_PUBLIC && visib <= TYPE_ATTRIBUTE_NESTED_FAM_OR_ASSEM)
5586                         continue;
5587                 n = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAME]);
5588                 nspace = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAMESPACE]);
5589                 if (g_strcasecmp (n, name) == 0 && g_strcasecmp (nspace, name_space) == 0)
5590                         return mono_class_get (image, MONO_TOKEN_TYPE_DEF | i);
5591         }
5592         return NULL;
5593 }
5594
5595 static MonoClass*
5596 return_nested_in (MonoClass *class, char *nested)
5597 {
5598         MonoClass *found;
5599         char *s = strchr (nested, '/');
5600         gpointer iter = NULL;
5601
5602         if (s) {
5603                 *s = 0;
5604                 s++;
5605         }
5606
5607         while ((found = mono_class_get_nested_types (class, &iter))) {
5608                 if (strcmp (found->name, nested) == 0) {
5609                         if (s)
5610                                 return return_nested_in (found, s);
5611                         return found;
5612                 }
5613         }
5614         return NULL;
5615 }
5616
5617 static MonoClass*
5618 search_modules (MonoImage *image, const char *name_space, const char *name)
5619 {
5620         MonoTableInfo *file_table = &image->tables [MONO_TABLE_FILE];
5621         MonoImage *file_image;
5622         MonoClass *class;
5623         int i;
5624
5625         /*
5626          * The EXPORTEDTYPES table only contains public types, so have to search the
5627          * modules as well.
5628          * Note: image->modules contains the contents of the MODULEREF table, while
5629          * the real module list is in the FILE table.
5630          */
5631         for (i = 0; i < file_table->rows; i++) {
5632                 guint32 cols [MONO_FILE_SIZE];
5633                 mono_metadata_decode_row (file_table, i, cols, MONO_FILE_SIZE);
5634                 if (cols [MONO_FILE_FLAGS] == FILE_CONTAINS_NO_METADATA)
5635                         continue;
5636
5637                 file_image = mono_image_load_file_for_image (image, i + 1);
5638                 if (file_image) {
5639                         class = mono_class_from_name (file_image, name_space, name);
5640                         if (class)
5641                                 return class;
5642                 }
5643         }
5644
5645         return NULL;
5646 }
5647
5648 /**
5649  * mono_class_from_name:
5650  * @image: The MonoImage where the type is looked up in
5651  * @name_space: the type namespace
5652  * @name: the type short name.
5653  *
5654  * Obtains a MonoClass with a given namespace and a given name which
5655  * is located in the given MonoImage.
5656  */
5657 MonoClass *
5658 mono_class_from_name (MonoImage *image, const char* name_space, const char *name)
5659 {
5660         GHashTable *nspace_table;
5661         MonoImage *loaded_image;
5662         guint32 token = 0;
5663         int i;
5664         MonoClass *class;
5665         char *nested;
5666         char buf [1024];
5667
5668         if ((nested = strchr (name, '/'))) {
5669                 int pos = nested - name;
5670                 int len = strlen (name);
5671                 if (len > 1023)
5672                         return NULL;
5673                 memcpy (buf, name, len + 1);
5674                 buf [pos] = 0;
5675                 nested = buf + pos + 1;
5676                 name = buf;
5677         }
5678
5679         if (get_class_from_name) {
5680                 gboolean res = get_class_from_name (image, name_space, name, &class);
5681                 if (res) {
5682                         if (!class)
5683                                 class = search_modules (image, name_space, name);
5684                         if (nested)
5685                                 return class ? return_nested_in (class, nested) : NULL;
5686                         else
5687                                 return class;
5688                 }
5689         }
5690
5691         mono_loader_lock ();
5692
5693         if (!image->name_cache)
5694                 mono_image_init_name_cache (image);
5695
5696         nspace_table = g_hash_table_lookup (image->name_cache, name_space);
5697
5698         if (nspace_table)
5699                 token = GPOINTER_TO_UINT (g_hash_table_lookup (nspace_table, name));
5700
5701         mono_loader_unlock ();
5702
5703         if (!token && image->dynamic && image->modules) {
5704                 /* Search modules as well */
5705                 for (i = 0; i < image->module_count; ++i) {
5706                         MonoImage *module = image->modules [i];
5707
5708                         class = mono_class_from_name (module, name_space, name);
5709                         if (class)
5710                                 return class;
5711                 }
5712         }
5713
5714         if (!token) {
5715                 class = search_modules (image, name_space, name);
5716                 if (class)
5717                         return class;
5718         }
5719
5720         if (!token)
5721                 return NULL;
5722
5723         if (mono_metadata_token_table (token) == MONO_TABLE_EXPORTEDTYPE) {
5724                 MonoTableInfo  *t = &image->tables [MONO_TABLE_EXPORTEDTYPE];
5725                 guint32 cols [MONO_EXP_TYPE_SIZE];
5726                 guint32 idx, impl;
5727
5728                 idx = mono_metadata_token_index (token);
5729
5730                 mono_metadata_decode_row (t, idx - 1, cols, MONO_EXP_TYPE_SIZE);
5731
5732                 impl = cols [MONO_EXP_TYPE_IMPLEMENTATION];
5733                 if ((impl & MONO_IMPLEMENTATION_MASK) == MONO_IMPLEMENTATION_FILE) {
5734                         loaded_image = mono_assembly_load_module (image->assembly, impl >> MONO_IMPLEMENTATION_BITS);
5735                         if (!loaded_image)
5736                                 return NULL;
5737                         class = mono_class_from_name (loaded_image, name_space, name);
5738                         if (nested)
5739                                 return return_nested_in (class, nested);
5740                         return class;
5741                 } else if ((impl & MONO_IMPLEMENTATION_MASK) == MONO_IMPLEMENTATION_ASSEMBLYREF) {
5742                         MonoAssembly **references = image->references;
5743                         guint32 assembly_idx;
5744
5745                         assembly_idx = impl >> MONO_IMPLEMENTATION_BITS;
5746
5747                         if (!references [assembly_idx - 1])
5748                                 mono_assembly_load_reference (image, assembly_idx - 1);
5749                         g_assert (references == image->references);
5750                         g_assert (references [assembly_idx - 1]);
5751                         if (references [assembly_idx - 1] == (gpointer)-1)
5752                                 return NULL;
5753                         else
5754                                 /* FIXME: Cycle detection */
5755                                 return mono_class_from_name (references [assembly_idx - 1]->image, name_space, name);
5756                 } else {
5757                         g_error ("not yet implemented");
5758                 }
5759         }
5760
5761         token = MONO_TOKEN_TYPE_DEF | token;
5762
5763         class = mono_class_get (image, token);
5764         if (nested)
5765                 return return_nested_in (class, nested);
5766         return class;
5767 }
5768
5769 gboolean
5770 mono_class_is_subclass_of (MonoClass *klass, MonoClass *klassc,
5771                            gboolean check_interfaces)
5772 {
5773         g_assert (klassc->idepth > 0);
5774         if (check_interfaces && MONO_CLASS_IS_INTERFACE (klassc) && !MONO_CLASS_IS_INTERFACE (klass)) {
5775                 if (MONO_CLASS_IMPLEMENTS_INTERFACE (klass, klassc->interface_id))
5776                         return TRUE;
5777         } else if (check_interfaces && MONO_CLASS_IS_INTERFACE (klassc) && MONO_CLASS_IS_INTERFACE (klass)) {
5778                 int i;
5779
5780                 for (i = 0; i < klass->interface_count; i ++) {
5781                         MonoClass *ic =  klass->interfaces [i];
5782                         if (ic == klassc)
5783                                 return TRUE;
5784                 }
5785         } else {
5786                 if (!MONO_CLASS_IS_INTERFACE (klass) && mono_class_has_parent (klass, klassc))
5787                         return TRUE;
5788         }
5789
5790         /*
5791          * MS.NET thinks interfaces are a subclass of Object, so we think it as
5792          * well.
5793          */
5794         if (klassc == mono_defaults.object_class)
5795                 return TRUE;
5796
5797         return FALSE;
5798 }
5799
5800 static gboolean
5801 mono_class_has_variant_generic_params (MonoClass *klass)
5802 {
5803         int i;
5804         MonoGenericContainer *container;
5805
5806         if (!klass->generic_class)
5807                 return FALSE;
5808
5809         container = klass->generic_class->container_class->generic_container;
5810
5811         for (i = 0; i < container->type_argc; ++i)
5812                 if (container->type_params [i].flags & (MONO_GEN_PARAM_VARIANT|MONO_GEN_PARAM_COVARIANT))
5813                         return TRUE;
5814
5815         return FALSE;
5816 }
5817
5818 /**
5819  * mono_class_is_assignable_from:
5820  * @klass: the class to be assigned to
5821  * @oklass: the source class
5822  *
5823  * Return: true if an instance of object oklass can be assigned to an
5824  * instance of object @klass
5825  */
5826 gboolean
5827 mono_class_is_assignable_from (MonoClass *klass, MonoClass *oklass)
5828 {
5829         if (!klass->inited)
5830                 mono_class_init (klass);
5831
5832         if (!oklass->inited)
5833                 mono_class_init (oklass);
5834
5835         if ((klass->byval_arg.type == MONO_TYPE_VAR) || (klass->byval_arg.type == MONO_TYPE_MVAR))
5836                 return klass == oklass;
5837
5838         if (MONO_CLASS_IS_INTERFACE (klass)) {
5839                 if ((oklass->byval_arg.type == MONO_TYPE_VAR) || (oklass->byval_arg.type == MONO_TYPE_MVAR))
5840                         return FALSE;
5841
5842                 /* interface_offsets might not be set for dynamic classes */
5843                 if (oklass->reflection_info && !oklass->interface_bitmap)
5844                         /*
5845                          * oklass might be a generic type parameter but they have
5846                          * interface_offsets set.
5847                          */
5848                         return mono_reflection_call_is_assignable_to (oklass, klass);
5849                 if (!oklass->interface_bitmap)
5850                         /* Happens with generic instances of not-yet created dynamic types */
5851                         return FALSE;
5852                 if (MONO_CLASS_IMPLEMENTS_INTERFACE (oklass, klass->interface_id))
5853                         return TRUE;
5854
5855                 if (mono_class_has_variant_generic_params (klass)) {
5856                         if (oklass->generic_class) {
5857                                 int i;
5858                                 gboolean match = FALSE;
5859                                 MonoClass *container_class1 = klass->generic_class->container_class;
5860                                 MonoClass *container_class2 = oklass->generic_class->container_class;
5861
5862                                 /*
5863                                  * Check whenever the generic definition of oklass implements the
5864                                  * generic definition of klass. The IMPLEMENTS_INTERFACE stuff is not usable
5865                                  * here since the relevant tables are not set up.
5866                                  */
5867                                 for (i = 0; i < container_class2->interface_offsets_count; ++i)
5868                                         if ((container_class2->interfaces_packed [i] == container_class1) || (container_class2->interfaces_packed [i]->generic_class && (container_class2->interfaces_packed [i]->generic_class->container_class == container_class1)))
5869                                                 match = TRUE;
5870
5871                                 if (match) {
5872                                         MonoGenericContainer *container;
5873
5874                                         container = klass->generic_class->container_class->generic_container;
5875
5876                                         match = TRUE;
5877                                         for (i = 0; i < container->type_argc; ++i) {
5878                                                 MonoClass *param1_class = mono_class_from_mono_type (klass->generic_class->context.class_inst->type_argv [i]);
5879                                                 MonoClass *param2_class = mono_class_from_mono_type (oklass->generic_class->context.class_inst->type_argv [i]);
5880
5881                                                 if (param1_class->valuetype != param2_class->valuetype) {
5882                                                         match = FALSE;
5883                                                         break;
5884                                                 }
5885                                                 /*
5886                                                  * The _VARIANT and _COVARIANT constants should read _COVARIANT and
5887                                                  * _CONTRAVARIANT, but they are in a public header so we can't fix it.
5888                                                  */
5889                                                 if (param1_class != param2_class) {
5890                                                         if ((container->type_params [i].flags & MONO_GEN_PARAM_VARIANT) && mono_class_is_assignable_from (param1_class, param2_class))
5891                                                                 ;
5892                                                         else if (((container->type_params [i].flags & MONO_GEN_PARAM_COVARIANT) && mono_class_is_assignable_from (param2_class, param1_class)))
5893                                                                 ;
5894                                                         else {
5895                                                                 match = FALSE;
5896                                                                 break;
5897                                                         }
5898                                                 }
5899                                         }
5900
5901                                         if (match)
5902                                                 return TRUE;
5903                                 }
5904                         }
5905                 }
5906         } else if (klass->rank) {
5907                 MonoClass *eclass, *eoclass;
5908
5909                 if (oklass->rank != klass->rank)
5910                         return FALSE;
5911
5912                 /* vectors vs. one dimensional arrays */
5913                 if (oklass->byval_arg.type != klass->byval_arg.type)
5914                         return FALSE;
5915
5916                 eclass = klass->cast_class;
5917                 eoclass = oklass->cast_class;
5918
5919                 /*
5920                  * a is b does not imply a[] is b[] when a is a valuetype, and
5921                  * b is a reference type.
5922                  */
5923
5924                 if (eoclass->valuetype) {
5925                         if ((eclass == mono_defaults.enum_class) ||
5926                                 (eclass == mono_defaults.enum_class->parent) ||
5927                                 (eclass == mono_defaults.object_class))
5928                                 return FALSE;
5929                 }
5930
5931                 return mono_class_is_assignable_from (klass->cast_class, oklass->cast_class);
5932         } else if (mono_class_is_nullable (klass)) {
5933                 if (mono_class_is_nullable (oklass))
5934                         return mono_class_is_assignable_from (klass->cast_class, oklass->cast_class);
5935                 else
5936                         return mono_class_is_assignable_from (klass->cast_class, oklass);
5937         } else if (klass == mono_defaults.object_class)
5938                 return TRUE;
5939
5940         return mono_class_has_parent (oklass, klass);
5941 }
5942
5943 /**
5944  * mono_class_get_cctor:
5945  * @klass: A MonoClass pointer
5946  *
5947  * Returns: the static constructor of @klass if it exists, NULL otherwise.
5948  */
5949 MonoMethod*
5950 mono_class_get_cctor (MonoClass *klass)
5951 {
5952         MonoCachedClassInfo cached_info;
5953
5954         if (!klass->has_cctor)
5955                 return NULL;
5956
5957         if (mono_class_get_cached_class_info (klass, &cached_info))
5958                 return mono_get_method (klass->image, cached_info.cctor_token, klass);
5959
5960         if (klass->generic_class && !klass->methods)
5961                 return mono_class_get_inflated_method (klass, mono_class_get_cctor (klass->generic_class->container_class));
5962
5963         return mono_class_get_method_from_name_flags (klass, ".cctor", -1, METHOD_ATTRIBUTE_SPECIAL_NAME);
5964 }
5965
5966 /**
5967  * mono_class_get_finalizer:
5968  * @klass: The MonoClass pointer
5969  *
5970  * Returns: the finalizer method of @klass if it exists, NULL otherwise.
5971  */
5972 MonoMethod*
5973 mono_class_get_finalizer (MonoClass *klass)
5974 {
5975         MonoCachedClassInfo cached_info;
5976
5977         if (!klass->inited)
5978                 mono_class_init (klass);
5979         if (!klass->has_finalize)
5980                 return NULL;
5981
5982         if (mono_class_get_cached_class_info (klass, &cached_info))
5983                 return mono_get_method (cached_info.finalize_image, cached_info.finalize_token, NULL);
5984         else {
5985                 mono_class_setup_vtable (klass);
5986                 return klass->vtable [finalize_slot];
5987         }
5988 }
5989
5990 /**
5991  * mono_class_needs_cctor_run:
5992  * @klass: the MonoClass pointer
5993  * @caller: a MonoMethod describing the caller
5994  *
5995  * Determines whenever the class has a static constructor and whenever it
5996  * needs to be called when executing CALLER.
5997  */
5998 gboolean
5999 mono_class_needs_cctor_run (MonoClass *klass, MonoMethod *caller)
6000 {
6001         MonoMethod *method;
6002
6003         method = mono_class_get_cctor (klass);
6004         if (method)
6005                 return (method == caller) ? FALSE : TRUE;
6006         else
6007                 return TRUE;
6008 }
6009
6010 /**
6011  * mono_class_array_element_size:
6012  * @klass:
6013  *
6014  * Returns: the number of bytes an element of type @klass
6015  * uses when stored into an array.
6016  */
6017 gint32
6018 mono_class_array_element_size (MonoClass *klass)
6019 {
6020         MonoType *type = &klass->byval_arg;
6021
6022 handle_enum:
6023         switch (type->type) {
6024         case MONO_TYPE_I1:
6025         case MONO_TYPE_U1:
6026         case MONO_TYPE_BOOLEAN:
6027                 return 1;
6028         case MONO_TYPE_I2:
6029         case MONO_TYPE_U2:
6030         case MONO_TYPE_CHAR:
6031                 return 2;
6032         case MONO_TYPE_I4:
6033         case MONO_TYPE_U4:
6034         case MONO_TYPE_R4:
6035                 return 4;
6036         case MONO_TYPE_I:
6037         case MONO_TYPE_U:
6038         case MONO_TYPE_PTR:
6039         case MONO_TYPE_CLASS:
6040         case MONO_TYPE_STRING:
6041         case MONO_TYPE_OBJECT:
6042         case MONO_TYPE_SZARRAY:
6043         case MONO_TYPE_ARRAY:
6044         case MONO_TYPE_VAR:
6045         case MONO_TYPE_MVAR:
6046                 return sizeof (gpointer);
6047         case MONO_TYPE_I8:
6048         case MONO_TYPE_U8:
6049         case MONO_TYPE_R8:
6050                 return 8;
6051         case MONO_TYPE_VALUETYPE:
6052                 if (type->data.klass->enumtype) {
6053                         type = type->data.klass->enum_basetype;
6054                         klass = klass->element_class;
6055                         goto handle_enum;
6056                 }
6057                 return mono_class_instance_size (klass) - sizeof (MonoObject);
6058         case MONO_TYPE_GENERICINST:
6059                 type = &type->data.generic_class->container_class->byval_arg;
6060                 goto handle_enum;
6061         default:
6062                 g_error ("unknown type 0x%02x in mono_class_array_element_size", type->type);
6063         }
6064         return -1;
6065 }
6066
6067 /**
6068  * mono_array_element_size:
6069  * @ac: pointer to a #MonoArrayClass
6070  *
6071  * Returns: the size of single array element.
6072  */
6073 gint32
6074 mono_array_element_size (MonoClass *ac)
6075 {
6076         g_assert (ac->rank);
6077         return ac->sizes.element_size;
6078 }
6079
6080 gpointer
6081 mono_ldtoken (MonoImage *image, guint32 token, MonoClass **handle_class,
6082               MonoGenericContext *context)
6083 {
6084         if (image->dynamic) {
6085                 MonoClass *tmp_handle_class;
6086                 gpointer obj = mono_lookup_dynamic_token_class (image, token, TRUE, &tmp_handle_class, context);
6087
6088                 g_assert (tmp_handle_class);
6089                 if (handle_class)
6090                         *handle_class = tmp_handle_class;
6091
6092                 if (tmp_handle_class == mono_defaults.typehandle_class)
6093                         return &((MonoClass*)obj)->byval_arg;
6094                 else
6095                         return obj;
6096         }
6097
6098         switch (token & 0xff000000) {
6099         case MONO_TOKEN_TYPE_DEF:
6100         case MONO_TOKEN_TYPE_REF:
6101         case MONO_TOKEN_TYPE_SPEC: {
6102                 MonoType *type;
6103                 if (handle_class)
6104                         *handle_class = mono_defaults.typehandle_class;
6105                 type = mono_type_get_full (image, token, context);
6106                 if (!type)
6107                         return NULL;
6108                 mono_class_init (mono_class_from_mono_type (type));
6109                 /* We return a MonoType* as handle */
6110                 return type;
6111         }
6112         case MONO_TOKEN_FIELD_DEF: {
6113                 MonoClass *class;
6114                 guint32 type = mono_metadata_typedef_from_field (image, mono_metadata_token_index (token));
6115                 if (handle_class)
6116                         *handle_class = mono_defaults.fieldhandle_class;
6117                 class = mono_class_get_full (image, MONO_TOKEN_TYPE_DEF | type, context);
6118                 if (!class)
6119                         return NULL;
6120                 mono_class_init (class);
6121                 return mono_class_get_field (class, token);
6122         }
6123         case MONO_TOKEN_METHOD_DEF:
6124         case MONO_TOKEN_METHOD_SPEC: {
6125                 MonoMethod *meth;
6126                 meth = mono_get_method_full (image, token, NULL, context);
6127                 if (handle_class)
6128                         *handle_class = mono_defaults.methodhandle_class;
6129                 return meth;
6130         }
6131         case MONO_TOKEN_MEMBER_REF: {
6132                 guint32 cols [MONO_MEMBERREF_SIZE];
6133                 const char *sig;
6134                 mono_metadata_decode_row (&image->tables [MONO_TABLE_MEMBERREF], mono_metadata_token_index (token) - 1, cols, MONO_MEMBERREF_SIZE);
6135                 sig = mono_metadata_blob_heap (image, cols [MONO_MEMBERREF_SIGNATURE]);
6136                 mono_metadata_decode_blob_size (sig, &sig);
6137                 if (*sig == 0x6) { /* it's a field */
6138                         MonoClass *klass;
6139                         MonoClassField *field;
6140                         field = mono_field_from_token (image, token, &klass, context);
6141                         if (handle_class)
6142                                 *handle_class = mono_defaults.fieldhandle_class;
6143                         return field;
6144                 } else {
6145                         MonoMethod *meth;
6146                         meth = mono_get_method_full (image, token, NULL, context);
6147                         if (handle_class)
6148                                 *handle_class = mono_defaults.methodhandle_class;
6149                         return meth;
6150                 }
6151         }
6152         default:
6153                 g_warning ("Unknown token 0x%08x in ldtoken", token);
6154                 break;
6155         }
6156         return NULL;
6157 }
6158
6159 /**
6160  * This function might need to call runtime functions so it can't be part
6161  * of the metadata library.
6162  */
6163 static MonoLookupDynamicToken lookup_dynamic = NULL;
6164
6165 void
6166 mono_install_lookup_dynamic_token (MonoLookupDynamicToken func)
6167 {
6168         lookup_dynamic = func;
6169 }
6170
6171 gpointer
6172 mono_lookup_dynamic_token (MonoImage *image, guint32 token, MonoGenericContext *context)
6173 {
6174         MonoClass *handle_class;
6175
6176         return lookup_dynamic (image, token, TRUE, &handle_class, context);
6177 }
6178
6179 gpointer
6180 mono_lookup_dynamic_token_class (MonoImage *image, guint32 token, gboolean valid_token, MonoClass **handle_class, MonoGenericContext *context)
6181 {
6182         return lookup_dynamic (image, token, valid_token, handle_class, context);
6183 }
6184
6185 static MonoGetCachedClassInfo get_cached_class_info = NULL;
6186
6187 void
6188 mono_install_get_cached_class_info (MonoGetCachedClassInfo func)
6189 {
6190         get_cached_class_info = func;
6191 }
6192
6193 static gboolean
6194 mono_class_get_cached_class_info (MonoClass *klass, MonoCachedClassInfo *res)
6195 {
6196         if (!get_cached_class_info)
6197                 return FALSE;
6198         else
6199                 return get_cached_class_info (klass, res);
6200 }
6201
6202 void
6203 mono_install_get_class_from_name (MonoGetClassFromName func)
6204 {
6205         get_class_from_name = func;
6206 }
6207
6208 MonoImage*
6209 mono_class_get_image (MonoClass *klass)
6210 {
6211         return klass->image;
6212 }
6213
6214 /**
6215  * mono_class_get_element_class:
6216  * @klass: the MonoClass to act on
6217  *
6218  * Returns: the element class of an array or an enumeration.
6219  */
6220 MonoClass*
6221 mono_class_get_element_class (MonoClass *klass)
6222 {
6223         return klass->element_class;
6224 }
6225
6226 /**
6227  * mono_class_is_valuetype:
6228  * @klass: the MonoClass to act on
6229  *
6230  * Returns: true if the MonoClass represents a ValueType.
6231  */
6232 gboolean
6233 mono_class_is_valuetype (MonoClass *klass)
6234 {
6235         return klass->valuetype;
6236 }
6237
6238 /**
6239  * mono_class_is_enum:
6240  * @klass: the MonoClass to act on
6241  *
6242  * Returns: true if the MonoClass represents an enumeration.
6243  */
6244 gboolean
6245 mono_class_is_enum (MonoClass *klass)
6246 {
6247         return klass->enumtype;
6248 }
6249
6250 /**
6251  * mono_class_enum_basetype:
6252  * @klass: the MonoClass to act on
6253  *
6254  * Returns: the underlying type representation for an enumeration.
6255  */
6256 MonoType*
6257 mono_class_enum_basetype (MonoClass *klass)
6258 {
6259         return klass->enum_basetype;
6260 }
6261
6262 /**
6263  * mono_class_get_parent
6264  * @klass: the MonoClass to act on
6265  *
6266  * Returns: the parent class for this class.
6267  */
6268 MonoClass*
6269 mono_class_get_parent (MonoClass *klass)
6270 {
6271         return klass->parent;
6272 }
6273
6274 /**
6275  * mono_class_get_nesting_type;
6276  * @klass: the MonoClass to act on
6277  *
6278  * Returns: the container type where this type is nested or NULL if this type is not a nested type.
6279  */
6280 MonoClass*
6281 mono_class_get_nesting_type (MonoClass *klass)
6282 {
6283         return klass->nested_in;
6284 }
6285
6286 /**
6287  * mono_class_get_rank:
6288  * @klass: the MonoClass to act on
6289  *
6290  * Returns: the rank for the array (the number of dimensions).
6291  */
6292 int
6293 mono_class_get_rank (MonoClass *klass)
6294 {
6295         return klass->rank;
6296 }
6297
6298 /**
6299  * mono_class_get_flags:
6300  * @klass: the MonoClass to act on
6301  *
6302  * The type flags from the TypeDef table from the metadata.
6303  * see the TYPE_ATTRIBUTE_* definitions on tabledefs.h for the
6304  * different values.
6305  *
6306  * Returns: the flags from the TypeDef table.
6307  */
6308 guint32
6309 mono_class_get_flags (MonoClass *klass)
6310 {
6311         return klass->flags;
6312 }
6313
6314 /**
6315  * mono_class_get_name
6316  * @klass: the MonoClass to act on
6317  *
6318  * Returns: the name of the class.
6319  */
6320 const char*
6321 mono_class_get_name (MonoClass *klass)
6322 {
6323         return klass->name;
6324 }
6325
6326 /**
6327  * mono_class_get_namespace:
6328  * @klass: the MonoClass to act on
6329  *
6330  * Returns: the namespace of the class.
6331  */
6332 const char*
6333 mono_class_get_namespace (MonoClass *klass)
6334 {
6335         return klass->name_space;
6336 }
6337
6338 /**
6339  * mono_class_get_type:
6340  * @klass: the MonoClass to act on
6341  *
6342  * This method returns the internal Type representation for the class.
6343  *
6344  * Returns: the MonoType from the class.
6345  */
6346 MonoType*
6347 mono_class_get_type (MonoClass *klass)
6348 {
6349         return &klass->byval_arg;
6350 }
6351
6352 /**
6353  * mono_class_get_type_token
6354  * @klass: the MonoClass to act on
6355  *
6356  * This method returns type token for the class.
6357  *
6358  * Returns: the type token for the class.
6359  */
6360 guint32
6361 mono_class_get_type_token (MonoClass *klass)
6362 {
6363   return klass->type_token;
6364 }
6365
6366 /**
6367  * mono_class_get_byref_type:
6368  * @klass: the MonoClass to act on
6369  *
6370  *
6371  */
6372 MonoType*
6373 mono_class_get_byref_type (MonoClass *klass)
6374 {
6375         return &klass->this_arg;
6376 }
6377
6378 /**
6379  * mono_class_num_fields:
6380  * @klass: the MonoClass to act on
6381  *
6382  * Returns: the number of static and instance fields in the class.
6383  */
6384 int
6385 mono_class_num_fields (MonoClass *klass)
6386 {
6387         return klass->field.count;
6388 }
6389
6390 /**
6391  * mono_class_num_methods:
6392  * @klass: the MonoClass to act on
6393  *
6394  * Returns: the number of methods in the class.
6395  */
6396 int
6397 mono_class_num_methods (MonoClass *klass)
6398 {
6399         return klass->method.count;
6400 }
6401
6402 /**
6403  * mono_class_num_properties
6404  * @klass: the MonoClass to act on
6405  *
6406  * Returns: the number of properties in the class.
6407  */
6408 int
6409 mono_class_num_properties (MonoClass *klass)
6410 {
6411         mono_class_setup_properties (klass);
6412
6413         return klass->property.count;
6414 }
6415
6416 /**
6417  * mono_class_num_events:
6418  * @klass: the MonoClass to act on
6419  *
6420  * Returns: the number of events in the class.
6421  */
6422 int
6423 mono_class_num_events (MonoClass *klass)
6424 {
6425         mono_class_setup_events (klass);
6426
6427         return klass->event.count;
6428 }
6429
6430 /**
6431  * mono_class_get_fields:
6432  * @klass: the MonoClass to act on
6433  *
6434  * This routine is an iterator routine for retrieving the fields in a class.
6435  *
6436  * You must pass a gpointer that points to zero and is treated as an opaque handle to
6437  * iterate over all of the elements.  When no more values are
6438  * available, the return value is NULL.
6439  *
6440  * Returns: a @MonoClassField* on each iteration, or NULL when no more fields are available.
6441  */
6442 MonoClassField*
6443 mono_class_get_fields (MonoClass* klass, gpointer *iter)
6444 {
6445         MonoClassField* field;
6446         if (!iter)
6447                 return NULL;
6448         if (!*iter) {
6449                 mono_class_setup_fields_locking (klass);
6450                 if (klass->exception_type)
6451                         return NULL;
6452                 /* start from the first */
6453                 if (klass->field.count) {
6454                         return *iter = &klass->fields [0];
6455                 } else {
6456                         /* no fields */
6457                         return NULL;
6458                 }
6459         }
6460         field = *iter;
6461         field++;
6462         if (field < &klass->fields [klass->field.count]) {
6463                 return *iter = field;
6464         }
6465         return NULL;
6466 }
6467
6468 /**
6469  * mono_class_get_methods
6470  * @klass: the MonoClass to act on
6471  *
6472  * This routine is an iterator routine for retrieving the fields in a class.
6473  *
6474  * You must pass a gpointer that points to zero and is treated as an opaque handle to
6475  * iterate over all of the elements.  When no more values are
6476  * available, the return value is NULL.
6477  *
6478  * Returns: a MonoMethod on each iteration or NULL when no more methods are available.
6479  */
6480 MonoMethod*
6481 mono_class_get_methods (MonoClass* klass, gpointer *iter)
6482 {
6483         MonoMethod** method;
6484         if (!iter)
6485                 return NULL;
6486         if (!klass->inited)
6487                 mono_class_init (klass);
6488         if (!*iter) {
6489                 mono_class_setup_methods (klass);
6490                 /* start from the first */
6491                 if (klass->method.count) {
6492                         *iter = &klass->methods [0];
6493                         return klass->methods [0];
6494                 } else {
6495                         /* no method */
6496                         return NULL;
6497                 }
6498         }
6499         method = *iter;
6500         method++;
6501         if (method < &klass->methods [klass->method.count]) {
6502                 *iter = method;
6503                 return *method;
6504         }
6505         return NULL;
6506 }
6507
6508 /*
6509  * mono_class_get_virtual_methods:
6510  *
6511  *   Iterate over the virtual methods of KLASS.
6512  *
6513  * LOCKING: Assumes the loader lock is held (because of the klass->methods check).
6514  */
6515 static MonoMethod*
6516 mono_class_get_virtual_methods (MonoClass* klass, gpointer *iter)
6517 {
6518         MonoMethod** method;
6519         if (!iter)
6520                 return NULL;
6521         if (klass->methods || !MONO_CLASS_HAS_STATIC_METADATA (klass) || mono_debug_using_mono_debugger ()) {
6522                 if (!*iter) {
6523                         mono_class_setup_methods (klass);
6524                         /* start from the first */
6525                         method = &klass->methods [0];
6526                 } else {
6527                         method = *iter;
6528                         method++;
6529                 }
6530                 while (method < &klass->methods [klass->method.count]) {
6531                         if (((*method)->flags & METHOD_ATTRIBUTE_VIRTUAL))
6532                                 break;
6533                         method ++;
6534                 }
6535                 if (method < &klass->methods [klass->method.count]) {
6536                         *iter = method;
6537                         return *method;
6538                 } else {
6539                         return NULL;
6540                 }
6541         } else {
6542                 /* Search directly in metadata to avoid calling setup_methods () */
6543                 MonoMethod *res = NULL;
6544                 int i, start_index;
6545
6546                 if (!*iter) {
6547                         start_index = 0;
6548                 } else {
6549                         start_index = GPOINTER_TO_UINT (*iter);
6550                 }
6551
6552                 for (i = start_index; i < klass->method.count; ++i) {
6553                         guint32 cols [MONO_METHOD_SIZE];
6554
6555                         /* class->method.first points into the methodptr table */
6556                         mono_metadata_decode_table_row (klass->image, MONO_TABLE_METHOD, klass->method.first + i, cols, MONO_METHOD_SIZE);
6557
6558                         if (cols [MONO_METHOD_FLAGS] & METHOD_ATTRIBUTE_VIRTUAL)
6559                                 break;
6560                 }
6561
6562                 if (i < klass->method.count) {
6563                         res = mono_get_method (klass->image, MONO_TOKEN_METHOD_DEF | (klass->method.first + i + 1), klass);
6564                         /* Add 1 here so the if (*iter) check fails */
6565                         *iter = GUINT_TO_POINTER (i + 1);
6566                         return res;
6567                 } else {
6568                         return NULL;
6569                 }
6570         }
6571 }
6572
6573 /**
6574  * mono_class_get_properties:
6575  * @klass: the MonoClass to act on
6576  *
6577  * This routine is an iterator routine for retrieving the properties in a class.
6578  *
6579  * You must pass a gpointer that points to zero and is treated as an opaque handle to
6580  * iterate over all of the elements.  When no more values are
6581  * available, the return value is NULL.
6582  *
6583  * Returns: a @MonoProperty* on each invocation, or NULL when no more are available.
6584  */
6585 MonoProperty*
6586 mono_class_get_properties (MonoClass* klass, gpointer *iter)
6587 {
6588         MonoProperty* property;
6589         if (!iter)
6590                 return NULL;
6591         if (!klass->inited)
6592                 mono_class_init (klass);
6593         if (!*iter) {
6594                 mono_class_setup_properties (klass);
6595                 /* start from the first */
6596                 if (klass->property.count) {
6597                         return *iter = &klass->properties [0];
6598                 } else {
6599                         /* no fields */
6600                         return NULL;
6601                 }
6602         }
6603         property = *iter;
6604         property++;
6605         if (property < &klass->properties [klass->property.count]) {
6606                 return *iter = property;
6607         }
6608         return NULL;
6609 }
6610
6611 /**
6612  * mono_class_get_events:
6613  * @klass: the MonoClass to act on
6614  *
6615  * This routine is an iterator routine for retrieving the properties in a class.
6616  *
6617  * You must pass a gpointer that points to zero and is treated as an opaque handle to
6618  * iterate over all of the elements.  When no more values are
6619  * available, the return value is NULL.
6620  *
6621  * Returns: a @MonoEvent* on each invocation, or NULL when no more are available.
6622  */
6623 MonoEvent*
6624 mono_class_get_events (MonoClass* klass, gpointer *iter)
6625 {
6626         MonoEvent* event;
6627         if (!iter)
6628                 return NULL;
6629         if (!klass->inited)
6630                 mono_class_init (klass);
6631         if (!*iter) {
6632                 mono_class_setup_events (klass);
6633                 /* start from the first */
6634                 if (klass->event.count) {
6635                         return *iter = &klass->events [0];
6636                 } else {
6637                         /* no fields */
6638                         return NULL;
6639                 }
6640         }
6641         event = *iter;
6642         event++;
6643         if (event < &klass->events [klass->event.count]) {
6644                 return *iter = event;
6645         }
6646         return NULL;
6647 }
6648
6649 /**
6650  * mono_class_get_interfaces
6651  * @klass: the MonoClass to act on
6652  *
6653  * This routine is an iterator routine for retrieving the interfaces implemented by this class.
6654  *
6655  * You must pass a gpointer that points to zero and is treated as an opaque handle to
6656  * iterate over all of the elements.  When no more values are
6657  * available, the return value is NULL.
6658  *
6659  * Returns: a @Monoclass* on each invocation, or NULL when no more are available.
6660  */
6661 MonoClass*
6662 mono_class_get_interfaces (MonoClass* klass, gpointer *iter)
6663 {
6664         MonoClass** iface;
6665         if (!iter)
6666                 return NULL;
6667         if (!klass->inited)
6668                 mono_class_init (klass);
6669         if (!*iter) {
6670                 /* start from the first */
6671                 if (klass->interface_count) {
6672                         *iter = &klass->interfaces [0];
6673                         return klass->interfaces [0];
6674                 } else {
6675                         /* no interface */
6676                         return NULL;
6677                 }
6678         }
6679         iface = *iter;
6680         iface++;
6681         if (iface < &klass->interfaces [klass->interface_count]) {
6682                 *iter = iface;
6683                 return *iface;
6684         }
6685         return NULL;
6686 }
6687
6688 /**
6689  * mono_class_get_nested_types
6690  * @klass: the MonoClass to act on
6691  *
6692  * This routine is an iterator routine for retrieving the nested types of a class.
6693  * This works only if @klass is non-generic, or a generic type definition.
6694  *
6695  * You must pass a gpointer that points to zero and is treated as an opaque handle to
6696  * iterate over all of the elements.  When no more values are
6697  * available, the return value is NULL.
6698  *
6699  * Returns: a @Monoclass* on each invocation, or NULL when no more are available.
6700  */
6701 MonoClass*
6702 mono_class_get_nested_types (MonoClass* klass, gpointer *iter)
6703 {
6704         GList *item;
6705         int i;
6706
6707         if (!iter)
6708                 return NULL;
6709         if (!klass->inited)
6710                 mono_class_init (klass);
6711         if (!klass->nested_classes_inited) {
6712                 if (!klass->type_token)
6713                         klass->nested_classes_inited = TRUE;
6714                 mono_loader_lock ();
6715                 if (!klass->nested_classes_inited) {
6716                         i = mono_metadata_nesting_typedef (klass->image, klass->type_token, 1);
6717                         while (i) {
6718                                 MonoClass* nclass;
6719                                 guint32 cols [MONO_NESTED_CLASS_SIZE];
6720                                 mono_metadata_decode_row (&klass->image->tables [MONO_TABLE_NESTEDCLASS], i - 1, cols, MONO_NESTED_CLASS_SIZE);
6721                                 nclass = mono_class_create_from_typedef (klass->image, MONO_TOKEN_TYPE_DEF | cols [MONO_NESTED_CLASS_NESTED]);
6722                                 klass->nested_classes = g_list_prepend_mempool (klass->nested_classes, klass->image->mempool, nclass);
6723
6724                                 i = mono_metadata_nesting_typedef (klass->image, klass->type_token, i + 1);
6725                         }
6726                 }
6727                 mono_memory_barrier ();
6728                 klass->nested_classes_inited = TRUE;
6729                 mono_loader_unlock ();
6730         }
6731
6732         if (!*iter) {
6733                 /* start from the first */
6734                 if (klass->nested_classes) {
6735                         *iter = klass->nested_classes;
6736                         return klass->nested_classes->data;
6737                 } else {
6738                         /* no nested types */
6739                         return NULL;
6740                 }
6741         }
6742         item = *iter;
6743         item = item->next;
6744         if (item) {
6745                 *iter = item;
6746                 return item->data;
6747         }
6748         return NULL;
6749 }
6750
6751 /**
6752  * mono_field_get_name:
6753  * @field: the MonoClassField to act on
6754  *
6755  * Returns: the name of the field.
6756  */
6757 const char*
6758 mono_field_get_name (MonoClassField *field)
6759 {
6760         return field->name;
6761 }
6762
6763 /**
6764  * mono_field_get_type:
6765  * @field: the MonoClassField to act on
6766  *
6767  * Returns: MonoType of the field.
6768  */
6769 MonoType*
6770 mono_field_get_type (MonoClassField *field)
6771 {
6772         return field->type;
6773 }
6774
6775 /**
6776  * mono_field_get_type:
6777  * @field: the MonoClassField to act on
6778  *
6779  * Returns: MonoClass where the field was defined.
6780  */
6781 MonoClass*
6782 mono_field_get_parent (MonoClassField *field)
6783 {
6784         return field->parent;
6785 }
6786
6787 /**
6788  * mono_field_get_flags;
6789  * @field: the MonoClassField to act on
6790  *
6791  * The metadata flags for a field are encoded using the
6792  * FIELD_ATTRIBUTE_* constants.  See the tabledefs.h file for details.
6793  *
6794  * Returns: the flags for the field.
6795  */
6796 guint32
6797 mono_field_get_flags (MonoClassField *field)
6798 {
6799         return field->type->attrs;
6800 }
6801
6802 /**
6803  * mono_field_get_offset;
6804  * @field: the MonoClassField to act on
6805  *
6806  * Returns: the field offset.
6807  */
6808 guint32
6809 mono_field_get_offset (MonoClassField *field)
6810 {
6811         return field->offset;
6812 }
6813
6814 static const char *
6815 mono_field_get_rva (MonoClassField *field)
6816 {
6817         guint32 rva;
6818         int field_index;
6819         MonoClass *klass = field->parent;
6820
6821         g_assert (field->type->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA);
6822
6823         if (!klass->field_def_values) {
6824                 mono_loader_lock ();
6825                 if (!klass->field_def_values)
6826                         klass->field_def_values = mono_image_alloc0 (klass->image, sizeof (MonoFieldDefaultValue) * klass->field.count);
6827                 mono_loader_unlock ();
6828         }
6829
6830         field_index = mono_field_get_index (field);
6831
6832         if (!klass->field_def_values [field_index].data && !klass->image->dynamic) {
6833                 mono_metadata_field_info (field->parent->image, klass->field.first + field_index, NULL, &rva, NULL);
6834                 if (!rva)
6835                         g_warning ("field %s in %s should have RVA data, but hasn't", mono_field_get_name (field), field->parent->name);
6836                 klass->field_def_values [field_index].data = mono_image_rva_map (field->parent->image, rva);
6837         }
6838
6839         return klass->field_def_values [field_index].data;
6840 }
6841
6842 /**
6843  * mono_field_get_data;
6844  * @field: the MonoClassField to act on
6845  *
6846  * Returns: pointer to the metadata constant value or to the field
6847  * data if it has an RVA flag.
6848  */
6849 const char *
6850 mono_field_get_data (MonoClassField *field)
6851 {
6852         if (field->type->attrs & FIELD_ATTRIBUTE_HAS_DEFAULT) {
6853                 MonoTypeEnum def_type;
6854
6855                 return mono_class_get_field_default_value (field, &def_type);
6856         } else if (field->type->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA) {
6857                 return mono_field_get_rva (field);
6858         } else {
6859                 return NULL;
6860         }
6861 }
6862
6863 /**
6864  * mono_property_get_name:
6865  * @prop: the MonoProperty to act on
6866  *
6867  * Returns: the name of the property
6868  */
6869 const char*
6870 mono_property_get_name (MonoProperty *prop)
6871 {
6872         return prop->name;
6873 }
6874
6875 /**
6876  * mono_property_get_set_method
6877  * @prop: the MonoProperty to act on.
6878  *
6879  * Returns: the setter method of the property (A MonoMethod)
6880  */
6881 MonoMethod*
6882 mono_property_get_set_method (MonoProperty *prop)
6883 {
6884         return prop->set;
6885 }
6886
6887 /**
6888  * mono_property_get_get_method
6889  * @prop: the MonoProperty to act on.
6890  *
6891  * Returns: the setter method of the property (A MonoMethod)
6892  */
6893 MonoMethod*
6894 mono_property_get_get_method (MonoProperty *prop)
6895 {
6896         return prop->get;
6897 }
6898
6899 /**
6900  * mono_property_get_parent:
6901  * @prop: the MonoProperty to act on.
6902  *
6903  * Returns: the MonoClass where the property was defined.
6904  */
6905 MonoClass*
6906 mono_property_get_parent (MonoProperty *prop)
6907 {
6908         return prop->parent;
6909 }
6910
6911 /**
6912  * mono_property_get_flags:
6913  * @prop: the MonoProperty to act on.
6914  *
6915  * The metadata flags for a property are encoded using the
6916  * PROPERTY_ATTRIBUTE_* constants.  See the tabledefs.h file for details.
6917  *
6918  * Returns: the flags for the property.
6919  */
6920 guint32
6921 mono_property_get_flags (MonoProperty *prop)
6922 {
6923         return prop->attrs;
6924 }
6925
6926 /**
6927  * mono_event_get_name:
6928  * @event: the MonoEvent to act on
6929  *
6930  * Returns: the name of the event.
6931  */
6932 const char*
6933 mono_event_get_name (MonoEvent *event)
6934 {
6935         return event->name;
6936 }
6937
6938 /**
6939  * mono_event_get_add_method:
6940  * @event: The MonoEvent to act on.
6941  *
6942  * Returns: the @add' method for the event (a MonoMethod).
6943  */
6944 MonoMethod*
6945 mono_event_get_add_method (MonoEvent *event)
6946 {
6947         return event->add;
6948 }
6949
6950 /**
6951  * mono_event_get_remove_method:
6952  * @event: The MonoEvent to act on.
6953  *
6954  * Returns: the @remove method for the event (a MonoMethod).
6955  */
6956 MonoMethod*
6957 mono_event_get_remove_method (MonoEvent *event)
6958 {
6959         return event->remove;
6960 }
6961
6962 /**
6963  * mono_event_get_raise_method:
6964  * @event: The MonoEvent to act on.
6965  *
6966  * Returns: the @raise method for the event (a MonoMethod).
6967  */
6968 MonoMethod*
6969 mono_event_get_raise_method (MonoEvent *event)
6970 {
6971         return event->raise;
6972 }
6973
6974 /**
6975  * mono_event_get_parent:
6976  * @event: the MonoEvent to act on.
6977  *
6978  * Returns: the MonoClass where the event is defined.
6979  */
6980 MonoClass*
6981 mono_event_get_parent (MonoEvent *event)
6982 {
6983         return event->parent;
6984 }
6985
6986 /**
6987  * mono_event_get_flags
6988  * @event: the MonoEvent to act on.
6989  *
6990  * The metadata flags for an event are encoded using the
6991  * EVENT_* constants.  See the tabledefs.h file for details.
6992  *
6993  * Returns: the flags for the event.
6994  */
6995 guint32
6996 mono_event_get_flags (MonoEvent *event)
6997 {
6998         return event->attrs;
6999 }
7000
7001 /**
7002  * mono_class_get_method_from_name:
7003  * @klass: where to look for the method
7004  * @name_space: name of the method
7005  * @param_count: number of parameters. -1 for any number.
7006  *
7007  * Obtains a MonoMethod with a given name and number of parameters.
7008  * It only works if there are no multiple signatures for any given method name.
7009  */
7010 MonoMethod *
7011 mono_class_get_method_from_name (MonoClass *klass, const char *name, int param_count)
7012 {
7013         return mono_class_get_method_from_name_flags (klass, name, param_count, 0);
7014 }
7015
7016 static MonoMethod*
7017 find_method_in_metadata (MonoClass *klass, const char *name, int param_count, int flags)
7018 {
7019         MonoMethod *res = NULL;
7020         int i;
7021
7022         /* Search directly in the metadata to avoid calling setup_methods () */
7023         for (i = 0; i < klass->method.count; ++i) {
7024                 guint32 cols [MONO_METHOD_SIZE];
7025                 MonoMethod *method;
7026
7027                 /* class->method.first points into the methodptr table */
7028                 mono_metadata_decode_table_row (klass->image, MONO_TABLE_METHOD, klass->method.first + i, cols, MONO_METHOD_SIZE);
7029
7030                 if (!strcmp (mono_metadata_string_heap (klass->image, cols [MONO_METHOD_NAME]), name)) {
7031                         method = mono_get_method (klass->image, MONO_TOKEN_METHOD_DEF | (klass->method.first + i + 1), klass);
7032                         if ((param_count == -1) || mono_method_signature (method)->param_count == param_count) {
7033                                 res = method;
7034                                 break;
7035                         }
7036                 }
7037         }
7038
7039         return res;
7040 }
7041
7042 /**
7043  * mono_class_get_method_from_name_flags:
7044  * @klass: where to look for the method
7045  * @name_space: name of the method
7046  * @param_count: number of parameters. -1 for any number.
7047  * @flags: flags which must be set in the method
7048  *
7049  * Obtains a MonoMethod with a given name and number of parameters.
7050  * It only works if there are no multiple signatures for any given method name.
7051  */
7052 MonoMethod *
7053 mono_class_get_method_from_name_flags (MonoClass *klass, const char *name, int param_count, int flags)
7054 {
7055         MonoMethod *res = NULL;
7056         int i;
7057
7058         mono_class_init (klass);
7059
7060         if (klass->methods || !MONO_CLASS_HAS_STATIC_METADATA (klass)) {
7061                 mono_class_setup_methods (klass);
7062                 for (i = 0; i < klass->method.count; ++i) {
7063                         MonoMethod *method = klass->methods [i];
7064
7065                         if (method->name[0] == name [0] &&
7066                                 !strcmp (name, method->name) &&
7067                                 (param_count == -1 || mono_method_signature (method)->param_count == param_count) &&
7068                                 ((method->flags & flags) == flags)) {
7069                                 res = method;
7070                                 break;
7071                         }
7072                 }
7073         }
7074         else {
7075             res = find_method_in_metadata (klass, name, param_count, flags);
7076         }
7077
7078         return res;
7079 }
7080
7081 /**
7082  * mono_class_set_failure:
7083  * @klass: class in which the failure was detected
7084  * @ex_type: the kind of exception/error to be thrown (later)
7085  * @ex_data: exception data (specific to each type of exception/error)
7086  *
7087  * Keep a detected failure informations in the class for later processing.
7088  * Note that only the first failure is kept.
7089  *
7090  * LOCKING: Acquires the loader lock.
7091  */
7092 gboolean
7093 mono_class_set_failure (MonoClass *klass, guint32 ex_type, void *ex_data)
7094 {
7095         if (klass->exception_type)
7096                 return FALSE;
7097
7098         mono_loader_lock ();
7099         klass->exception_type = ex_type;
7100         if (ex_data)
7101                 mono_property_hash_insert (klass->image->property_hash, klass, MONO_CLASS_PROP_EXCEPTION_DATA, ex_data);
7102         mono_loader_unlock ();
7103
7104         return TRUE;
7105 }
7106
7107 /*
7108  * mono_class_get_exception_data:
7109  *
7110  *   Return the exception_data property of KLASS.
7111  *
7112  * LOCKING: Acquires the loader lock.
7113  */
7114 gpointer
7115 mono_class_get_exception_data (MonoClass *klass)
7116 {
7117         gpointer res;
7118
7119         mono_loader_lock ();
7120         res = mono_property_hash_lookup (klass->image->property_hash, klass, MONO_CLASS_PROP_EXCEPTION_DATA);
7121         mono_loader_unlock ();
7122         return res;
7123 }
7124
7125 /**
7126  * mono_classes_init:
7127  *
7128  * Initialize the resources used by this module.
7129  */
7130 void
7131 mono_classes_init (void)
7132 {
7133 }
7134
7135 /**
7136  * mono_classes_cleanup:
7137  *
7138  * Free the resources used by this module.
7139  */
7140 void
7141 mono_classes_cleanup (void)
7142 {
7143         if (global_interface_bitset)
7144                 mono_bitset_free (global_interface_bitset);
7145 }
7146
7147 /**
7148  * mono_class_get_exception_for_failure:
7149  * @klass: class in which the failure was detected
7150  *
7151  * Return a constructed MonoException than the caller can then throw
7152  * using mono_raise_exception - or NULL if no failure is present (or
7153  * doesn't result in an exception).
7154  */
7155 MonoException*
7156 mono_class_get_exception_for_failure (MonoClass *klass)
7157 {
7158         gpointer exception_data = mono_class_get_exception_data (klass);
7159
7160         switch (klass->exception_type) {
7161         case MONO_EXCEPTION_SECURITY_INHERITANCEDEMAND: {
7162                 MonoDomain *domain = mono_domain_get ();
7163                 MonoSecurityManager* secman = mono_security_manager_get_methods ();
7164                 MonoMethod *method = exception_data;
7165                 guint32 error = (method) ? MONO_METADATA_INHERITANCEDEMAND_METHOD : MONO_METADATA_INHERITANCEDEMAND_CLASS;
7166                 MonoObject *exc = NULL;
7167                 gpointer args [4];
7168
7169                 args [0] = &error;
7170                 args [1] = mono_assembly_get_object (domain, mono_image_get_assembly (klass->image));
7171                 args [2] = mono_type_get_object (domain, &klass->byval_arg);
7172                 args [3] = (method) ? mono_method_get_object (domain, method, NULL) : NULL;
7173
7174                 mono_runtime_invoke (secman->inheritsecurityexception, NULL, args, &exc);
7175                 return (MonoException*) exc;
7176         }
7177         case MONO_EXCEPTION_TYPE_LOAD: {
7178                 MonoString *name;
7179                 MonoException *ex;
7180                 char *str = mono_type_get_full_name (klass);
7181                 char *astr = klass->image->assembly? mono_stringify_assembly_name (&klass->image->assembly->aname): NULL;
7182                 name = mono_string_new (mono_domain_get (), str);
7183                 g_free (str);
7184                 ex = mono_get_exception_type_load (name, astr);
7185                 g_free (astr);
7186                 return ex;
7187         }
7188         case MONO_EXCEPTION_MISSING_METHOD: {
7189                 char *class_name = exception_data;
7190                 char *assembly_name = class_name + strlen (class_name) + 1;
7191
7192                 return mono_get_exception_missing_method (class_name, assembly_name);
7193         }
7194         case MONO_EXCEPTION_MISSING_FIELD: {
7195                 char *class_name = exception_data;
7196                 char *member_name = class_name + strlen (class_name) + 1;
7197
7198                 return mono_get_exception_missing_field (class_name, member_name);
7199         }
7200         case MONO_EXCEPTION_FILE_NOT_FOUND: {
7201                 char *msg_format = exception_data;
7202                 char *assembly_name = msg_format + strlen (msg_format) + 1;
7203                 char *msg = g_strdup_printf (msg_format, assembly_name);
7204                 MonoException *ex;
7205
7206                 ex = mono_get_exception_file_not_found2 (msg, mono_string_new (mono_domain_get (), assembly_name));
7207
7208                 g_free (msg);
7209
7210                 return ex;
7211         }
7212         case MONO_EXCEPTION_BAD_IMAGE: {
7213                 return mono_get_exception_bad_image_format (exception_data);
7214         }
7215         default: {
7216                 MonoLoaderError *error;
7217                 MonoException *ex;
7218
7219                 error = mono_loader_get_last_error ();
7220                 if (error != NULL){
7221                         ex = mono_loader_error_prepare_exception (error);
7222                         return ex;
7223                 }
7224
7225                 /* TODO - handle other class related failures */
7226                 return NULL;
7227         }
7228         }
7229 }
7230
7231 static gboolean
7232 is_nesting_type (MonoClass *outer_klass, MonoClass *inner_klass)
7233  {
7234         outer_klass = mono_class_get_generic_type_definition (outer_klass);
7235         inner_klass = mono_class_get_generic_type_definition (inner_klass);
7236         do {
7237                 if (outer_klass == inner_klass)
7238                         return TRUE;
7239                 inner_klass = inner_klass->nested_in;
7240         } while (inner_klass);
7241         return FALSE;
7242 }
7243
7244 MonoClass *
7245 mono_class_get_generic_type_definition (MonoClass *klass)
7246 {
7247         return klass->generic_class ? klass->generic_class->container_class : klass;
7248 }
7249
7250 /*
7251  * Check if @klass is a subtype of @parent ignoring generic instantiations.
7252  *
7253  * Generic instantiations are ignored for all super types of @klass.
7254  *
7255  * Visibility checks ignoring generic instantiations.
7256  */
7257 gboolean
7258 mono_class_has_parent_and_ignore_generics (MonoClass *klass, MonoClass *parent)
7259 {
7260         int i;
7261         klass = mono_class_get_generic_type_definition (klass);
7262         parent = mono_class_get_generic_type_definition (parent);
7263
7264         for (i = 0; i < klass->idepth; ++i) {
7265                 if (parent == mono_class_get_generic_type_definition (klass->supertypes [i]))
7266                         return TRUE;
7267         }
7268         return FALSE;
7269 }
7270 /*
7271  * Subtype can only access parent members with family protection if the site object
7272  * is subclass of Subtype. For example:
7273  * class A { protected int x; }
7274  * class B : A {
7275  *      void valid_access () {
7276  *              B b;
7277  *              b.x = 0;
7278  *  }
7279  *  void invalid_access () {
7280  *              A a;
7281  *              a.x = 0;
7282  *  }
7283  * }
7284  * */
7285 static gboolean
7286 is_valid_family_access (MonoClass *access_klass, MonoClass *member_klass, MonoClass *context_klass)
7287 {
7288         if (!mono_class_has_parent_and_ignore_generics (access_klass, member_klass))
7289                 return FALSE;
7290
7291         if (context_klass == NULL)
7292                 return TRUE;
7293         /*if access_klass is not member_klass context_klass must be type compat*/
7294         if (access_klass != member_klass && !mono_class_has_parent_and_ignore_generics (context_klass, access_klass))
7295                 return FALSE;
7296         return TRUE;
7297 }
7298
7299 static gboolean
7300 can_access_internals (MonoAssembly *accessing, MonoAssembly* accessed)
7301 {
7302         GSList *tmp;
7303         if (accessing == accessed)
7304                 return TRUE;
7305         if (!accessed || !accessing)
7306                 return FALSE;
7307         mono_assembly_load_friends (accessed);
7308         for (tmp = accessed->friend_assembly_names; tmp; tmp = tmp->next) {
7309                 MonoAssemblyName *friend = tmp->data;
7310                 /* Be conservative with checks */
7311                 if (!friend->name)
7312                         continue;
7313                 if (strcmp (accessing->aname.name, friend->name))
7314                         continue;
7315                 if (friend->public_key_token [0]) {
7316                         if (!accessing->aname.public_key_token [0])
7317                                 continue;
7318                         if (!mono_public_tokens_are_equal (friend->public_key_token, accessing->aname.public_key_token))
7319                                 continue;
7320                 }
7321                 return TRUE;
7322         }
7323         return FALSE;
7324 }
7325
7326 /*
7327  * If klass is a generic type or if it is derived from a generic type, return the
7328  * MonoClass of the generic definition
7329  * Returns NULL if not found
7330  */
7331 static MonoClass*
7332 get_generic_definition_class (MonoClass *klass)
7333 {
7334         while (klass) {
7335                 if (klass->generic_class && klass->generic_class->container_class)
7336                         return klass->generic_class->container_class;
7337                 klass = klass->parent;
7338         }
7339         return NULL;
7340 }
7341
7342 static gboolean
7343 can_access_instantiation (MonoClass *access_klass, MonoGenericInst *ginst)
7344 {
7345         int i;
7346         for (i = 0; i < ginst->type_argc; ++i) {
7347                 MonoType *type = ginst->type_argv[i];
7348                 if (type->type == MONO_TYPE_VAR || type->type == MONO_TYPE_MVAR)
7349                         continue;
7350                 if (!can_access_type (access_klass, mono_class_from_mono_type (type)))
7351                         return FALSE;
7352         }
7353         return TRUE;
7354 }
7355
7356 static gboolean
7357 can_access_type (MonoClass *access_klass, MonoClass *member_klass)
7358 {
7359         int access_level = member_klass->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK;
7360
7361         if (member_klass->generic_class && !can_access_instantiation (access_klass, member_klass->generic_class->context.class_inst))
7362                 return FALSE;
7363
7364         if (is_nesting_type (access_klass, member_klass) || (access_klass->nested_in && is_nesting_type (access_klass->nested_in, member_klass)))
7365                 return TRUE;
7366
7367         if (member_klass->nested_in && !can_access_type (access_klass, member_klass->nested_in))
7368                 return FALSE;
7369
7370         switch (access_level) {
7371         case TYPE_ATTRIBUTE_NOT_PUBLIC:
7372                 return can_access_internals (access_klass->image->assembly, member_klass->image->assembly);
7373
7374         case TYPE_ATTRIBUTE_PUBLIC:
7375                 return TRUE;
7376
7377         case TYPE_ATTRIBUTE_NESTED_PUBLIC:
7378                 return TRUE;
7379
7380         case TYPE_ATTRIBUTE_NESTED_PRIVATE:
7381                 return is_nesting_type (member_klass, access_klass);
7382
7383         case TYPE_ATTRIBUTE_NESTED_FAMILY:
7384                 return mono_class_has_parent_and_ignore_generics (access_klass, member_klass->nested_in);
7385
7386         case TYPE_ATTRIBUTE_NESTED_ASSEMBLY:
7387                 return can_access_internals (access_klass->image->assembly, member_klass->image->assembly);
7388
7389         case TYPE_ATTRIBUTE_NESTED_FAM_AND_ASSEM:
7390                 return can_access_internals (access_klass->image->assembly, member_klass->nested_in->image->assembly) &&
7391                         mono_class_has_parent_and_ignore_generics (access_klass, member_klass->nested_in);
7392
7393         case TYPE_ATTRIBUTE_NESTED_FAM_OR_ASSEM:
7394                 return can_access_internals (access_klass->image->assembly, member_klass->nested_in->image->assembly) ||
7395                         mono_class_has_parent_and_ignore_generics (access_klass, member_klass->nested_in);
7396         }
7397         return FALSE;
7398 }
7399
7400 /* FIXME: check visibility of type, too */
7401 static gboolean
7402 can_access_member (MonoClass *access_klass, MonoClass *member_klass, MonoClass* context_klass, int access_level)
7403 {
7404         MonoClass *member_generic_def;
7405         if (((access_klass->generic_class && access_klass->generic_class->container_class) ||
7406                                         access_klass->generic_container) &&
7407                         (member_generic_def = get_generic_definition_class (member_klass))) {
7408                 MonoClass *access_container;
7409
7410                 if (access_klass->generic_container)
7411                         access_container = access_klass;
7412                 else
7413                         access_container = access_klass->generic_class->container_class;
7414
7415                 if (can_access_member (access_container, member_generic_def, context_klass, access_level))
7416                         return TRUE;
7417         }
7418
7419         /* Partition I 8.5.3.2 */
7420         /* the access level values are the same for fields and methods */
7421         switch (access_level) {
7422         case FIELD_ATTRIBUTE_COMPILER_CONTROLLED:
7423                 /* same compilation unit */
7424                 return access_klass->image == member_klass->image;
7425         case FIELD_ATTRIBUTE_PRIVATE:
7426                 return access_klass == member_klass;
7427         case FIELD_ATTRIBUTE_FAM_AND_ASSEM:
7428                 if (is_valid_family_access (access_klass, member_klass, context_klass) &&
7429                     can_access_internals (access_klass->image->assembly, member_klass->image->assembly))
7430                         return TRUE;
7431                 return FALSE;
7432         case FIELD_ATTRIBUTE_ASSEMBLY:
7433                 return can_access_internals (access_klass->image->assembly, member_klass->image->assembly);
7434         case FIELD_ATTRIBUTE_FAMILY:
7435                 if (is_valid_family_access (access_klass, member_klass, context_klass))
7436                         return TRUE;
7437                 return FALSE;
7438         case FIELD_ATTRIBUTE_FAM_OR_ASSEM:
7439                 if (is_valid_family_access (access_klass, member_klass, context_klass))
7440                         return TRUE;
7441                 return can_access_internals (access_klass->image->assembly, member_klass->image->assembly);
7442         case FIELD_ATTRIBUTE_PUBLIC:
7443                 return TRUE;
7444         }
7445         return FALSE;
7446 }
7447
7448 gboolean
7449 mono_method_can_access_field (MonoMethod *method, MonoClassField *field)
7450 {
7451         /* FIXME: check all overlapping fields */
7452         int can = can_access_member (method->klass, field->parent, NULL, field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK);
7453         if (!can) {
7454                 MonoClass *nested = method->klass->nested_in;
7455                 while (nested) {
7456                         can = can_access_member (nested, field->parent, NULL, field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK);
7457                         if (can)
7458                                 return TRUE;
7459                         nested = nested->nested_in;
7460                 }
7461         }
7462         return can;
7463 }
7464
7465 gboolean
7466 mono_method_can_access_method (MonoMethod *method, MonoMethod *called)
7467 {
7468         int can = can_access_member (method->klass, called->klass, NULL, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
7469         if (!can) {
7470                 MonoClass *nested = method->klass->nested_in;
7471                 while (nested) {
7472                         can = can_access_member (nested, called->klass, NULL, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
7473                         if (can)
7474                                 return TRUE;
7475                         nested = nested->nested_in;
7476                 }
7477         }
7478         /*
7479          * FIXME:
7480          * with generics calls to explicit interface implementations can be expressed
7481          * directly: the method is private, but we must allow it. This may be opening
7482          * a hole or the generics code should handle this differently.
7483          * Maybe just ensure the interface type is public.
7484          */
7485         if ((called->flags & METHOD_ATTRIBUTE_VIRTUAL) && (called->flags & METHOD_ATTRIBUTE_FINAL))
7486                 return TRUE;
7487         return can;
7488 }
7489
7490 /*
7491  * mono_method_can_access_method_with_context:
7492  * @method: The caller method
7493  * @called: The called method
7494  * @context_klass:TThe static type on stack of the owner @called object used
7495  *
7496  * This function must be used with instance calls, as they have more strict family accessibility.
7497  * It can be used with static mehthod, but context_klass should be NULL.
7498  *
7499  * Returns: TRUE if caller have proper visibility and acessibility to @called
7500  */
7501 gboolean
7502 mono_method_can_access_method_full (MonoMethod *method, MonoMethod *called, MonoClass *context_klass)
7503 {
7504         MonoClass *access_class = method->klass;
7505         MonoClass *member_class = called->klass;
7506         int can = can_access_member (access_class, member_class, context_klass, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
7507         if (!can) {
7508                 MonoClass *nested = access_class->nested_in;
7509                 while (nested) {
7510                         can = can_access_member (nested, member_class, context_klass, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
7511                         if (can)
7512                                 break;
7513                         nested = nested->nested_in;
7514                 }
7515         }
7516
7517         if (!can)
7518                 return FALSE;
7519
7520         if (!can_access_type (access_class, member_class) && (!access_class->nested_in || !can_access_type (access_class->nested_in, member_class)))
7521                 return FALSE;
7522
7523         if (called->is_inflated) {
7524                 MonoMethodInflated * infl = (MonoMethodInflated*)called;
7525                 if (infl->context.method_inst && !can_access_instantiation (access_class, infl->context.method_inst))
7526                 return FALSE;
7527         }
7528
7529         return TRUE;
7530 }
7531
7532
7533 /*
7534  * mono_method_can_access_method_with_context:
7535  * @method: The caller method
7536  * @field: The accessed field
7537  * @context_klass: The static type on stack of the owner @field object used
7538  *
7539  * This function must be used with instance fields, as they have more strict family accessibility.
7540  * It can be used with static fields, but context_klass should be NULL.
7541  *
7542  * Returns: TRUE if caller have proper visibility and acessibility to @field
7543  */
7544 gboolean
7545 mono_method_can_access_field_full (MonoMethod *method, MonoClassField *field, MonoClass *context_klass)
7546 {
7547         MonoClass *access_class = method->klass;
7548         MonoClass *member_class = field->parent;
7549         /* FIXME: check all overlapping fields */
7550         int can = can_access_member (access_class, member_class, context_klass, field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK);
7551         if (!can) {
7552                 MonoClass *nested = access_class->nested_in;
7553                 while (nested) {
7554                         can = can_access_member (nested, member_class, context_klass, field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK);
7555                         if (can)
7556                                 break;
7557                         nested = nested->nested_in;
7558                 }
7559         }
7560
7561         if (!can)
7562                 return FALSE;
7563
7564         if (!can_access_type (access_class, member_class) && (!access_class->nested_in || !can_access_type (access_class->nested_in, member_class)))
7565                 return FALSE;
7566         return TRUE;
7567 }
7568
7569 /**
7570  * mono_type_is_valid_enum_basetype:
7571  * @type: The MonoType to check
7572  *
7573  * Returns: TRUE if the type can be used as the basetype of an enum
7574  */
7575 gboolean mono_type_is_valid_enum_basetype (MonoType * type) {
7576         switch (type->type) {
7577         case MONO_TYPE_I1:
7578         case MONO_TYPE_U1:
7579         case MONO_TYPE_BOOLEAN:
7580         case MONO_TYPE_I2:
7581         case MONO_TYPE_U2:
7582         case MONO_TYPE_CHAR:
7583         case MONO_TYPE_I4:
7584         case MONO_TYPE_U4:
7585         case MONO_TYPE_I8:
7586         case MONO_TYPE_U8:
7587         case MONO_TYPE_I:
7588         case MONO_TYPE_U:
7589                 return TRUE;
7590         }
7591         return FALSE;
7592 }
7593
7594 /**
7595  * mono_class_is_valid_enum:
7596  * @klass: An enum class to be validated
7597  *
7598  * This method verify the required properties an enum should have.
7599  *
7600  * Returns: TRUE if the informed enum class is valid
7601  *
7602  * FIXME: TypeBuilder enums are allowed to implement interfaces, but since they cannot have methods, only empty interfaces are possible
7603  * FIXME: enum types are not allowed to have a cctor, but mono_reflection_create_runtime_class sets has_cctor to 1 for all types
7604  * FIXME: TypeBuilder enums can have any kind of static fields, but the spec is very explicit about that (P II 14.3)
7605  */
7606 gboolean mono_class_is_valid_enum (MonoClass *klass) {
7607         MonoClassField * field;
7608         gpointer iter = NULL;
7609         gboolean found_base_field = FALSE;
7610
7611         g_assert (klass->enumtype);
7612         /* we cannot test against mono_defaults.enum_class, or mcs won't be able to compile the System namespace*/
7613         if (!klass->parent || strcmp (klass->parent->name, "Enum") || strcmp (klass->parent->name_space, "System") ) {
7614                 return FALSE;
7615         }
7616
7617         if ((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) != TYPE_ATTRIBUTE_AUTO_LAYOUT)
7618                 return FALSE;
7619
7620         while ((field = mono_class_get_fields (klass, &iter))) {
7621                 if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC)) {
7622                         if (found_base_field)
7623                                 return FALSE;
7624                         found_base_field = TRUE;
7625                         if (!mono_type_is_valid_enum_basetype (field->type))
7626                                 return FALSE;
7627                 }
7628         }
7629
7630         if (!found_base_field)
7631                 return FALSE;
7632
7633         if (klass->method.count > 0)
7634                 return FALSE;
7635
7636         return TRUE;
7637 }
7638
7639 gboolean
7640 mono_generic_class_is_generic_type_definition (MonoGenericClass *gklass)
7641 {
7642         return gklass->context.class_inst == gklass->container_class->generic_container->context.class_inst;
7643 }
7644
7645 /*
7646  * mono_class_generic_sharing_enabled:
7647  * @class: a class
7648  *
7649  * Returns whether generic sharing is enabled for class.
7650  *
7651  * This is a stop-gap measure to slowly introduce generic sharing
7652  * until we have all the issues sorted out, at which time this
7653  * function will disappear and generic sharing will always be enabled.
7654  */
7655 gboolean
7656 mono_class_generic_sharing_enabled (MonoClass *class)
7657 {
7658 #if defined(__i386__) || defined(__x86_64__) || defined(__arm__) || defined(__mono_ppc__)
7659         static gboolean supported = TRUE;
7660 #else
7661         /* Not supported by the JIT backends */
7662         static gboolean supported = FALSE;
7663 #endif
7664         static int generic_sharing = MONO_GENERIC_SHARING_NONE;
7665         static gboolean inited = FALSE;
7666
7667         if (!inited) {
7668                 const char *option;
7669
7670                 if (supported)
7671                         generic_sharing = MONO_GENERIC_SHARING_ALL;
7672                 else
7673                         generic_sharing = MONO_GENERIC_SHARING_NONE;
7674
7675                 if ((option = g_getenv ("MONO_GENERIC_SHARING"))) {
7676                         if (strcmp (option, "corlib") == 0)
7677                                 generic_sharing = MONO_GENERIC_SHARING_CORLIB;
7678                         else if (strcmp (option, "collections") == 0)
7679                                 generic_sharing = MONO_GENERIC_SHARING_COLLECTIONS;
7680                         else if (strcmp (option, "all") == 0)
7681                                 generic_sharing = MONO_GENERIC_SHARING_ALL;
7682                         else if (strcmp (option, "none") == 0)
7683                                 generic_sharing = MONO_GENERIC_SHARING_NONE;
7684                         else
7685                                 g_warning ("Unknown generic sharing option `%s'.", option);
7686                 }
7687
7688                 if (!supported)
7689                         generic_sharing = MONO_GENERIC_SHARING_NONE;
7690
7691                 inited = TRUE;
7692         }
7693
7694         switch (generic_sharing) {
7695         case MONO_GENERIC_SHARING_NONE:
7696                 return FALSE;
7697         case MONO_GENERIC_SHARING_ALL:
7698                 return TRUE;
7699         case MONO_GENERIC_SHARING_CORLIB :
7700                 return class->image == mono_defaults.corlib;
7701         case MONO_GENERIC_SHARING_COLLECTIONS:
7702                 if (class->image != mono_defaults.corlib)
7703                         return FALSE;
7704                 while (class->nested_in)
7705                         class = class->nested_in;
7706                 return g_str_has_prefix (class->name_space, "System.Collections.Generic");
7707         default:
7708                 g_assert_not_reached ();
7709         }
7710 }
7711
7712 /*
7713  * mono_class_setup_interface_id:
7714  *
7715  * Initializes MonoClass::interface_id if required.
7716  *
7717  * LOCKING: Acquires the loader lock.
7718  */
7719 void
7720 mono_class_setup_interface_id (MonoClass *class)
7721 {
7722         mono_loader_lock ();
7723         if (MONO_CLASS_IS_INTERFACE (class) && !class->interface_id)
7724                 class->interface_id = mono_get_unique_iid (class);
7725         mono_loader_unlock ();
7726 }