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 Ximian, Inc.
   8  *
   9  * Possible Optimizations:
  10  *     in mono_class_create, do not allocate the class right away,
  11  *     but wait until you know the size of the FieldMap, so that
  12  *     the class embeds directly the FieldMap after the vtable.
  13  *
  14  *
  15  */
  16 #include <config.h>
  17 #include <glib.h>
  18 #include <stdio.h>
  19 #include <mono/metadata/image.h>
  20 #include <mono/metadata/cil-coff.h>
  21 #include <mono/metadata/metadata.h>
  22 #include <mono/metadata/tabledefs.h>
  23 #include <mono/metadata/tokentype.h>
  24 #include <mono/metadata/class.h>
  25 #include <mono/metadata/object.h>
  26
  27 #define CSIZE(x) (sizeof (x) / 4)
  28
  29 static MonoClass *
  30 mono_class_create_from_typeref (MonoImage *image, guint32 type_token)
  31 {
  32         guint32 cols [MONO_TYPEREF_SIZE];
  33         MonoTableInfo  *t = &image->tables [MONO_TABLE_TYPEREF];
  34         guint32 idx;
  35         const char *name, *nspace;
  36         MonoClass *res;
  37
  38         mono_metadata_decode_row (t, (type_token&0xffffff)-1, cols, MONO_TYPEREF_SIZE);
  39         g_assert ((cols [MONO_TYPEREF_SCOPE] & 0x3) == 2);
  40         idx = cols [MONO_TYPEREF_SCOPE] >> 2;
  41
  42         if (!image->references ||  !image->references [idx-1]) {
  43                 /*
  44                  * detected a reference to mscorlib, we simply return a reference to a dummy
  45                  * until we have a better solution.
  46                  */
  47                 res = mono_class_from_name (image, "System", "MonoDummy");
  48                 /* prevent method loading */
  49                 res->dummy = 1;
  50                 /* some storage if the type is used  - very ugly hack */
  51                 res->instance_size = 2*sizeof (gpointer);
  52                 return res;
  53         }
  54
  55         name = mono_metadata_string_heap (image, cols [MONO_TYPEREF_NAME]);
  56         nspace = mono_metadata_string_heap (image, cols [MONO_TYPEREF_NAMESPACE]);
  57
  58         /* load referenced assembly */
  59         image = image->references [idx-1]->image;
  60
  61         return mono_class_from_name (image, nspace, name);
  62 }
  63
  64 /**
  65  * class_compute_field_layout:
  66  * @m: pointer to the metadata.
  67  * @class: The class to initialize
  68  *
  69  * Initializes the class->fields.
  70  *
  71  * Currently we only support AUTO_LAYOUT, and do not even try to do
  72  * a good job at it.  This is temporary to get the code for Paolo.
  73  */
  74 static void
  75 class_compute_field_layout (MonoClass *class)
  76 {
  77         MonoImage *m = class->image;
  78         const int top = class->field.count;
  79         guint32 layout = class->flags & TYPE_ATTRIBUTE_LAYOUT_MASK;
  80         MonoTableInfo *t = &m->tables [MONO_TABLE_FIELD];
  81         int i, j;
  82
  83         /*
  84          * Fetch all the field information.
  85          */
  86         for (i = 0; i < top; i++){
  87                 const char *sig;
  88                 guint32 cols [3];
  89                 int idx = class->field.first + i;
  90
  91                 mono_metadata_decode_row (t, idx, cols, CSIZE (cols));
  92                 sig = mono_metadata_blob_heap (m, cols [2]);
  93                 mono_metadata_decode_value (sig, &sig);
  94                 /* FIELD signature == 0x06 */
  95                 g_assert (*sig == 0x06);
  96                 class->fields [i].type = mono_metadata_parse_field_type (
  97                         m, cols [MONO_FIELD_FLAGS], sig + 1, &sig);
  98         }
  99         /*
 100          * Compute field layout and total size.
 101          */
 102         switch (layout){
 103         case TYPE_ATTRIBUTE_AUTO_LAYOUT:
 104         case TYPE_ATTRIBUTE_SEQUENTIAL_LAYOUT:
 105                 for (i = 0; i < top; i++){
 106                         int size, align;
 107
 108                         size = mono_type_size (class->fields [i].type, &align);
 109                         if (class->fields [i].type->attrs & FIELD_ATTRIBUTE_STATIC) {
 110                                 class->fields [i].offset = class->class_size;
 111                                 class->class_size += (class->class_size % align);
 112                                 class->class_size += size;
 113                         } else {
 114                                 class->fields [i].offset = class->instance_size;
 115                                 class->instance_size += (class->instance_size % align);
 116                                 class->instance_size += size;
 117                         }
 118                 }
 119                 break;
 120         case TYPE_ATTRIBUTE_EXPLICIT_LAYOUT:
 121                 for (i = 0; i < top; i++){
 122                         guint32 cols [2];
 123                         int size, align;
 124                         int idx = class->field.first + i;
 125
 126                         t = &m->tables [MONO_TABLE_FIELDLAYOUT];
 127
 128                         for (j = 0; j < t->rows; j++) {
 129
 130                                 mono_metadata_decode_row (t, j, cols, CSIZE (cols));
 131                                 if (cols [1] == idx) {
 132                                         g_warning ("TODO: Explicit layout not supported yet");
 133                                 }
 134                         }
 135
 136                         size = mono_type_size (class->fields [i].type, &align);
 137                         if (class->fields [i].type->attrs & FIELD_ATTRIBUTE_STATIC) {
 138                                 class->fields [i].offset = class->class_size;
 139                                 class->class_size += (class->class_size % align);
 140                                 class->class_size += size;
 141                         } else {
 142                                 class->fields [i].offset = class->instance_size;
 143                                 class->instance_size += (class->instance_size % align);
 144                                 class->instance_size += size;
 145                         }
 146                 }
 147                 break;
 148         }
 149 }
 150
 151 void
 152 mono_class_metadata_init (MonoClass *class)
 153 {
 154         int i;
 155
 156         if (class->metadata_inited)
 157                 return;
 158
 159         if (class->parent && !class->parent->metadata_inited)
 160                  mono_class_metadata_init (class->parent);
 161
 162         class->metadata_inited = 1;
 163
 164
 165         /*
 166          * Computes the size used by the fields, and their locations
 167          */
 168         if (class->field.count > 0){
 169                 class->fields = g_new (MonoClassField, class->field.count);
 170                 class_compute_field_layout (class);
 171         }
 172
 173         if (!class->method.count)
 174                 return;
 175
 176         class->methods = g_new (MonoMethod*, class->method.count);
 177         for (i = class->method.first; i < class->method.last; ++i)
 178                 class->methods [i - class->method.first] =
 179                         mono_get_method (class->image,
 180                                          MONO_TOKEN_METHOD_DEF | (i + 1),
 181                                          class);
 182 }
 183
 184 /**
 185  * @image: context where the image is created
 186  * @type_token:  typedef token
 187  */
 188 static MonoClass *
 189 mono_class_create_from_typedef (MonoImage *image, guint32 type_token)
 190 {
 191         MonoTableInfo *tt = &image->tables [MONO_TABLE_TYPEDEF];
 192         MonoClass *class;
 193         guint32 cols [MONO_TYPEDEF_SIZE], parent_token;
 194         guint tidx = mono_metadata_token_index (type_token);
 195         const char *name, *nspace;
 196
 197         g_assert (mono_metadata_token_table (type_token) == MONO_TABLE_TYPEDEF);
 198
 199         class = g_malloc0 (sizeof (MonoClass));
 200
 201         class->this_arg.byref = 1;
 202         class->this_arg.data.klass = class;
 203         class->this_arg.type = MONO_TYPE_CLASS;
 204
 205         mono_metadata_decode_row (tt, tidx-1, cols, CSIZE (cols));
 206         class->name = name = mono_metadata_string_heap (image, cols[1]);
 207         class->name_space = nspace = mono_metadata_string_heap (image, cols[2]);
 208
 209         class->image = image;
 210         class->type_token = type_token;
 211         class->flags = cols [0];
 212
 213
 214         /*g_print ("Init class %s\n", name);*/
 215
 216         /* if root of the hierarchy */
 217         if (!strcmp (nspace, "System") && !strcmp (name, "Object")) {
 218                 class->instance_size = sizeof (MonoObject);
 219                 class->parent = NULL;
 220         } else if (!(cols [0] & TYPE_ATTRIBUTE_INTERFACE)) {
 221                 parent_token = mono_metadata_token_from_dor (cols [3]);
 222                 class->parent = mono_class_get (image, parent_token);
 223                 class->instance_size = class->parent->instance_size;
 224                 class->valuetype = class->parent->valuetype;
 225                 class->enumtype = class->parent->enumtype;
 226                 g_assert (class->instance_size);
 227         }
 228
 229         if (!strcmp (nspace, "System")) {
 230                 if (!strcmp (name, "ValueType")) {
 231                         class->valuetype = 1;
 232                 } else if (!strcmp (name, "Enum")) {
 233                         class->valuetype = 1;
 234                         class->enumtype = 1;
 235                 }
 236         }
 237         if (class->valuetype)
 238                 class->this_arg.type = MONO_TYPE_VALUETYPE;
 239
 240         /*
 241          * Compute the field and method lists
 242          */
 243         class->field.first  = cols [MONO_TYPEDEF_FIELD_LIST] - 1;
 244         class->method.first = cols [MONO_TYPEDEF_METHOD_LIST] - 1;
 245
 246         if (tt->rows > tidx){
 247                 guint32 cols_next [MONO_TYPEDEF_SIZE];
 248
 249                 mono_metadata_decode_row (tt, tidx, cols_next, CSIZE (cols_next));
 250                 class->field.last  = cols_next [MONO_TYPEDEF_FIELD_LIST] - 1;
 251                 class->method.last = cols_next [MONO_TYPEDEF_METHOD_LIST] - 1;
 252         } else {
 253                 class->field.last  = image->tables [MONO_TABLE_FIELD].rows;
 254                 class->method.last = image->tables [MONO_TABLE_METHOD].rows;
 255         }
 256
 257         if (cols [MONO_TYPEDEF_FIELD_LIST] &&
 258             cols [MONO_TYPEDEF_FIELD_LIST] <= image->tables [MONO_TABLE_FIELD].rows)
 259                 class->field.count = class->field.last - class->field.first;
 260         else
 261                 class->field.count = 0;
 262
 263         if (cols [MONO_TYPEDEF_METHOD_LIST] <= image->tables [MONO_TABLE_METHOD].rows)
 264                 class->method.count = class->method.last - class->method.first;
 265         else
 266                 class->method.count = 0;
 267
 268         /* reserve space to store vector pointer in arrays */
 269         if (!strcmp (nspace, "System") && !strcmp (name, "Array")) {
 270                 class->instance_size += 2 * sizeof (gpointer);
 271                 g_assert (class->field.count == 0);
 272                 g_assert (class->instance_size == sizeof (MonoArrayObject));
 273         }
 274
 275         return class;
 276 }
 277
 278 static MonoClass *
 279 mono_class_from_mono_type (MonoType *type)
 280 {
 281         MonoImage *corlib;
 282         MonoClass *res;
 283
 284         corlib = mono_defaults.corlib;
 285
 286         switch (type->type) {
 287         case MONO_TYPE_BOOLEAN:
 288                 res = mono_defaults.boolean_class;
 289                 break;
 290         case MONO_TYPE_CHAR:
 291                 res = mono_defaults.char_class;
 292                 break;
 293         case MONO_TYPE_I1:
 294                 res = mono_defaults.byte_class;
 295                 break;
 296         case MONO_TYPE_U1:
 297                 res = mono_defaults.sbyte_class;
 298                 break;
 299         case MONO_TYPE_I2:
 300                 res = mono_defaults.int16_class;
 301                 break;
 302         case MONO_TYPE_U2:
 303                 res = mono_defaults.uint16_class;
 304                 break;
 305         case MONO_TYPE_I4:
 306                 res = mono_defaults.int32_class;
 307                 break;
 308         case MONO_TYPE_U4:
 309                 res = mono_defaults.uint32_class;
 310                 break;
 311         case MONO_TYPE_I8:
 312                 res = mono_defaults.int64_class;
 313                 break;
 314         case MONO_TYPE_U8:
 315                 res = mono_defaults.uint64_class;
 316                 break;
 317         case MONO_TYPE_R4:
 318                 res = mono_defaults.single_class;
 319                 break;
 320         case MONO_TYPE_R8:
 321                 res = mono_defaults.double_class;
 322                 break;
 323         case MONO_TYPE_STRING:
 324                 res = mono_defaults.string_class;
 325                 break;
 326         case MONO_TYPE_CLASS:
 327                 res = type->data.klass;
 328                 break;
 329         default:
 330                 g_warning ("implement me %08x\n", type->type);
 331                 g_assert_not_reached ();
 332         }
 333
 334         return res;
 335 }
 336
 337 /**
 338  * @image: context where the image is created
 339  * @type_spec:  typespec token
 340  * @at: an optional pointer to return the array type
 341  */
 342 static MonoClass *
 343 mono_class_create_from_typespec (MonoImage *image, guint32 type_spec)
 344 {
 345         guint32 idx = mono_metadata_token_index (type_spec);
 346         MonoTableInfo *t;
 347         guint32 cols [MONO_TYPESPEC_SIZE];
 348         const char *ptr;
 349         guint32 len;
 350         MonoType *type;
 351         MonoClass *class, *eclass;
 352
 353         t = &image->tables [MONO_TABLE_TYPESPEC];
 354
 355         mono_metadata_decode_row (t, idx-1, cols, MONO_TYPESPEC_SIZE);
 356         ptr = mono_metadata_blob_heap (image, cols [MONO_TYPESPEC_SIGNATURE]);
 357         len = mono_metadata_decode_value (ptr, &ptr);
 358         type = mono_metadata_parse_type (image, MONO_PARSE_TYPE, 0, ptr, &ptr);
 359
 360         switch (type->type) {
 361         case MONO_TYPE_ARRAY:
 362                 eclass = mono_class_from_mono_type (type->data.array->type);
 363                 class = mono_array_class_get (eclass, type->data.array->rank);
 364                 break;
 365         case MONO_TYPE_SZARRAY:
 366                 eclass = mono_class_from_mono_type (type->data.type);
 367                 class = mono_array_class_get (eclass, 1);
 368                 break;
 369         default:
 370                 g_warning ("implement me: %08x", type->type);
 371                 g_assert_not_reached ();
 372         }
 373
 374         mono_metadata_free_type (type);
 375
 376         return class;
 377 }
 378
 379 /**
 380  * mono_array_class_get:
 381  * @eclass: element type class
 382  * @rank: the dimension of the array class
 383  *
 384  * Returns: a class object describing the array with element type @etype and
 385  * dimension @rank.
 386  */
 387 MonoClass *
 388 mono_array_class_get (MonoClass *eclass, guint32 rank)
 389 {
 390         MonoImage *image;
 391         MonoClass *class;
 392         static MonoClass *parent = NULL;
 393         MonoArrayClass *aclass;
 394         guint32 key;
 395
 396         g_assert (rank <= 255);
 397
 398         if (!parent)
 399                 parent = mono_defaults.array_class;
 400
 401         image = eclass->image;
 402
 403         g_assert (!eclass->type_token ||
 404                   mono_metadata_token_table (eclass->type_token) == MONO_TABLE_TYPEDEF);
 405
 406         key = ((rank & 0xff) << 24) | (eclass->type_token & 0xffffff);
 407         if ((class = g_hash_table_lookup (image->array_cache, GUINT_TO_POINTER (key))))
 408                 return class;
 409
 410         aclass = g_new0 (MonoArrayClass, 1);
 411         class = (MonoClass *)aclass;
 412
 413         class->image = image;
 414         class->name_space = "System";
 415         class->name = "Array";
 416         class->type_token = 0;
 417         class->flags = TYPE_ATTRIBUTE_CLASS;
 418         class->parent = parent;
 419         class->instance_size = mono_class_instance_size (class->parent);
 420         class->class_size = 0;
 421
 422         aclass->rank = rank;
 423         aclass->element_class = eclass;
 424
 425         g_hash_table_insert (image->array_cache, GUINT_TO_POINTER (key), class);
 426         return class;
 427 }
 428
 429 /**
 430  * mono_class_instance_size:
 431  * @klass: a class
 432  *
 433  * Returns: the size of an object instance
 434  */
 435 gint32
 436 mono_class_instance_size (MonoClass *klass)
 437 {
 438
 439         if (!klass->metadata_inited)
 440                 mono_class_metadata_init (klass);
 441
 442         return klass->instance_size;
 443 }
 444
 445 /**
 446  * mono_class_value_size:
 447  * @klass: a class
 448  *
 449  * This function is used for value types, and return the
 450  * space and the alignment to store that kind of value object.
 451  *
 452  * Returns: the size of a value of kind @klass
 453  */
 454 gint32
 455 mono_class_value_size      (MonoClass *klass, guint32 *align)
 456 {
 457         gint32 size;
 458
 459         /* fixme: check disable, because we still have external revereces to
 460          * mscorlib and Dummy Objects
 461          */
 462         //g_assert (klass->valuetype);
 463
 464         size = mono_class_instance_size (klass) - sizeof (MonoObject);
 465
 466         if (align) {
 467                 if (size <= 4)
 468                         *align = 4;
 469                 else
 470                         *align = 8;
 471         }
 472
 473         return size;
 474 }
 475
 476 /**
 477  * mono_class_data_size:
 478  * @klass: a class
 479  *
 480  * Returns: the size of the static class data
 481  */
 482 gint32
 483 mono_class_data_size (MonoClass *klass)
 484 {
 485
 486         if (!klass->metadata_inited)
 487                 mono_class_metadata_init (klass);
 488
 489         return klass->class_size;
 490 }
 491
 492 /*
 493  * Auxiliary routine to mono_class_get_field
 494  *
 495  * Takes a field index instead of a field token.
 496  */
 497 static MonoClassField *
 498 mono_class_get_field_idx (MonoClass *class, int idx)
 499 {
 500         if (class->field.count){
 501                 if ((idx >= class->field.first) && (idx < class->field.last)){
 502                         return &class->fields [idx - class->field.first];
 503                 }
 504         }
 505
 506         if (!class->parent)
 507                 return NULL;
 508
 509         return mono_class_get_field_idx (class->parent, idx);
 510 }
 511
 512 /**
 513  * mono_class_get_field:
 514  * @class: the class to lookup the field.
 515  * @field_token: the field token
 516  *
 517  * Returns: A MonoClassField representing the type and offset of
 518  * the field, or a NULL value if the field does not belong to this
 519  * class.
 520  */
 521 MonoClassField *
 522 mono_class_get_field (MonoClass *class, guint32 field_token)
 523 {
 524         int idx = mono_metadata_token_index (field_token);
 525
 526         if (mono_metadata_token_code (field_token) == MONO_TOKEN_MEMBER_REF)
 527                 g_error ("Unsupported Field Token is a MemberRef, implement me");
 528
 529         g_assert (mono_metadata_token_code (field_token) == MONO_TOKEN_FIELD_DEF);
 530
 531         return mono_class_get_field_idx (class, idx - 1);
 532 }
 533
 534 /**
 535  * mono_class_get:
 536  * @image: the image where the class resides
 537  * @type_token: the token for the class
 538  * @at: an optional pointer to return the array element type
 539  *
 540  * Returns: the MonoClass that represents @type_token in @image
 541  */
 542 MonoClass *
 543 mono_class_get (MonoImage *image, guint32 type_token)
 544 {
 545         MonoClass *class;
 546
 547         switch (type_token & 0xff000000){
 548         case MONO_TOKEN_TYPE_DEF:
 549                 if ((class = g_hash_table_lookup (image->class_cache,
 550                                                   GUINT_TO_POINTER (type_token))))
 551                         return class;
 552                 class = mono_class_create_from_typedef (image, type_token);
 553                 break;
 554         case MONO_TOKEN_TYPE_REF:
 555                 return mono_class_create_from_typeref (image, type_token);
 556         case MONO_TOKEN_TYPE_SPEC:
 557                 if ((class = g_hash_table_lookup (image->class_cache,
 558                                                   GUINT_TO_POINTER (type_token))))
 559                         return class;
 560
 561                 class = mono_class_create_from_typespec (image, type_token);
 562                 break;
 563         default:
 564                 g_assert_not_reached ();
 565         }
 566
 567         g_hash_table_insert (image->class_cache, GUINT_TO_POINTER (type_token), class);
 568
 569         return class;
 570 }
 571
 572 MonoClass *
 573 mono_class_from_name (MonoImage *image, const char* name_space, const char *name)
 574 {
 575         GHashTable *nspace_table;
 576         guint32 token;
 577
 578         nspace_table = g_hash_table_lookup (image->name_cache, name_space);
 579         if (!nspace_table)
 580                 return 0;
 581         token = GPOINTER_TO_UINT (g_hash_table_lookup (nspace_table, name));
 582
 583         if (!token)
 584                 g_error ("token not found for %s.%s in image %s", name_space, name, image->name);
 585
 586         token = MONO_TOKEN_TYPE_DEF | token;
 587
 588         return mono_class_get (image, token);
 589 }
 590
 591 /**
 592  * mono_array_element_size:
 593  * @ac: pointer to a #MonoArrayClass
 594  *
 595  * Returns: the size of single array element.
 596  */
 597 gint32
 598 mono_array_element_size (MonoArrayClass *ac)
 599 {
 600         gint32 esize;
 601
 602         esize = mono_class_instance_size (ac->element_class);
 603
 604         if (ac->element_class->valuetype)
 605                 esize -= sizeof (MonoObject);
 606
 607         return esize;
 608 }