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