mono/metadata/class.c

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