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 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_OBJECT:
 288                 res = mono_defaults.object_class;
 289                 break;
 290         case MONO_TYPE_VOID:
 291                 res = mono_defaults.void_class;
 292                 break;
 293         case MONO_TYPE_BOOLEAN:
 294                 res = mono_defaults.boolean_class;
 295                 break;
 296         case MONO_TYPE_CHAR:
 297                 res = mono_defaults.char_class;
 298                 break;
 299         case MONO_TYPE_I1:
 300                 res = mono_defaults.byte_class;
 301                 break;
 302         case MONO_TYPE_U1:
 303                 res = mono_defaults.sbyte_class;
 304                 break;
 305         case MONO_TYPE_I2:
 306                 res = mono_defaults.int16_class;
 307                 break;
 308         case MONO_TYPE_U2:
 309                 res = mono_defaults.uint16_class;
 310                 break;
 311         case MONO_TYPE_I4:
 312                 res = mono_defaults.int32_class;
 313                 break;
 314         case MONO_TYPE_U4:
 315                 res = mono_defaults.uint32_class;
 316                 break;
 317         case MONO_TYPE_I:
 318                 res = mono_defaults.int_class;
 319                 break;
 320         case MONO_TYPE_U:
 321                 res = mono_defaults.uint_class;
 322                 break;
 323         case MONO_TYPE_I8:
 324                 res = mono_defaults.int64_class;
 325                 break;
 326         case MONO_TYPE_U8:
 327                 res = mono_defaults.uint64_class;
 328                 break;
 329         case MONO_TYPE_R4:
 330                 res = mono_defaults.single_class;
 331                 break;
 332         case MONO_TYPE_R8:
 333                 res = mono_defaults.double_class;
 334                 break;
 335         case MONO_TYPE_STRING:
 336                 res = mono_defaults.string_class;
 337                 break;
 338         case MONO_TYPE_SZARRAY:
 339         case MONO_TYPE_PTR:
 340                 res = mono_class_from_mono_type (type->data.type);
 341                 break;
 342         case MONO_TYPE_CLASS:
 343         case MONO_TYPE_VALUETYPE:
 344                 res = type->data.klass;
 345                 break;
 346         default:
 347                 g_warning ("implement me %02x\n", type->type);
 348                 g_assert_not_reached ();
 349         }
 350
 351         return res;
 352 }
 353
 354 /**
 355  * @image: context where the image is created
 356  * @type_spec:  typespec token
 357  * @at: an optional pointer to return the array type
 358  */
 359 static MonoClass *
 360 mono_class_create_from_typespec (MonoImage *image, guint32 type_spec)
 361 {
 362         guint32 idx = mono_metadata_token_index (type_spec);
 363         MonoTableInfo *t;
 364         guint32 cols [MONO_TYPESPEC_SIZE];
 365         const char *ptr;
 366         guint32 len;
 367         MonoType *type;
 368         MonoClass *class, *eclass;
 369
 370         t = &image->tables [MONO_TABLE_TYPESPEC];
 371
 372         mono_metadata_decode_row (t, idx-1, cols, MONO_TYPESPEC_SIZE);
 373         ptr = mono_metadata_blob_heap (image, cols [MONO_TYPESPEC_SIGNATURE]);
 374         len = mono_metadata_decode_value (ptr, &ptr);
 375         type = mono_metadata_parse_type (image, MONO_PARSE_TYPE, 0, ptr, &ptr);
 376
 377         switch (type->type) {
 378         case MONO_TYPE_ARRAY:
 379                 eclass = mono_class_from_mono_type (type->data.array->type);
 380                 class = mono_array_class_get (eclass, type->data.array->rank);
 381                 break;
 382         case MONO_TYPE_SZARRAY:
 383                 eclass = mono_class_from_mono_type (type->data.type);
 384                 class = mono_array_class_get (eclass, 1);
 385                 break;
 386         default:
 387                 g_warning ("implement me: %08x", type->type);
 388                 g_assert_not_reached ();
 389         }
 390
 391         mono_metadata_free_type (type);
 392
 393         return class;
 394 }
 395
 396 /**
 397  * mono_array_class_get:
 398  * @eclass: element type class
 399  * @rank: the dimension of the array class
 400  *
 401  * Returns: a class object describing the array with element type @etype and
 402  * dimension @rank.
 403  */
 404 MonoClass *
 405 mono_array_class_get (MonoClass *eclass, guint32 rank)
 406 {
 407         MonoImage *image;
 408         MonoClass *class;
 409         static MonoClass *parent = NULL;
 410         MonoArrayClass *aclass;
 411         guint32 key;
 412
 413         g_assert (rank <= 255);
 414
 415         if (!parent)
 416                 parent = mono_defaults.array_class;
 417
 418         image = eclass->image;
 419
 420         g_assert (!eclass->type_token ||
 421                   mono_metadata_token_table (eclass->type_token) == MONO_TABLE_TYPEDEF);
 422
 423         key = ((rank & 0xff) << 24) | (eclass->type_token & 0xffffff);
 424         if ((class = g_hash_table_lookup (image->array_cache, GUINT_TO_POINTER (key))))
 425                 return class;
 426
 427         aclass = g_new0 (MonoArrayClass, 1);
 428         class = (MonoClass *)aclass;
 429
 430         class->image = image;
 431         class->name_space = "System";
 432         class->name = "Array";
 433         class->type_token = 0;
 434         class->flags = TYPE_ATTRIBUTE_CLASS;
 435         class->parent = parent;
 436         class->instance_size = mono_class_instance_size (class->parent);
 437         class->class_size = 0;
 438
 439         aclass->rank = rank;
 440         aclass->element_class = eclass;
 441
 442         g_hash_table_insert (image->array_cache, GUINT_TO_POINTER (key), class);
 443         return class;
 444 }
 445
 446 /**
 447  * mono_class_instance_size:
 448  * @klass: a class
 449  *
 450  * Returns: the size of an object instance
 451  */
 452 gint32
 453 mono_class_instance_size (MonoClass *klass)
 454 {
 455
 456         if (!klass->metadata_inited)
 457                 mono_class_metadata_init (klass);
 458
 459         return klass->instance_size;
 460 }
 461
 462 /**
 463  * mono_class_value_size:
 464  * @klass: a class
 465  *
 466  * This function is used for value types, and return the
 467  * space and the alignment to store that kind of value object.
 468  *
 469  * Returns: the size of a value of kind @klass
 470  */
 471 gint32
 472 mono_class_value_size      (MonoClass *klass, guint32 *align)
 473 {
 474         gint32 size;
 475
 476         /* fixme: check disable, because we still have external revereces to
 477          * mscorlib and Dummy Objects
 478          */
 479         //g_assert (klass->valuetype);
 480
 481         size = mono_class_instance_size (klass) - sizeof (MonoObject);
 482
 483         if (align) {
 484                 if (size <= 4)
 485                         *align = 4;
 486                 else
 487                         *align = 8;
 488         }
 489
 490         return size;
 491 }
 492
 493 /**
 494  * mono_class_data_size:
 495  * @klass: a class
 496  *
 497  * Returns: the size of the static class data
 498  */
 499 gint32
 500 mono_class_data_size (MonoClass *klass)
 501 {
 502
 503         if (!klass->metadata_inited)
 504                 mono_class_metadata_init (klass);
 505
 506         return klass->class_size;
 507 }
 508
 509 /*
 510  * Auxiliary routine to mono_class_get_field
 511  *
 512  * Takes a field index instead of a field token.
 513  */
 514 static MonoClassField *
 515 mono_class_get_field_idx (MonoClass *class, int idx)
 516 {
 517         if (class->field.count){
 518                 if ((idx >= class->field.first) && (idx < class->field.last)){
 519                         return &class->fields [idx - class->field.first];
 520                 }
 521         }
 522
 523         if (!class->parent)
 524                 return NULL;
 525
 526         return mono_class_get_field_idx (class->parent, idx);
 527 }
 528
 529 /**
 530  * mono_class_get_field:
 531  * @class: the class to lookup the field.
 532  * @field_token: the field token
 533  *
 534  * Returns: A MonoClassField representing the type and offset of
 535  * the field, or a NULL value if the field does not belong to this
 536  * class.
 537  */
 538 MonoClassField *
 539 mono_class_get_field (MonoClass *class, guint32 field_token)
 540 {
 541         int idx = mono_metadata_token_index (field_token);
 542
 543         if (mono_metadata_token_code (field_token) == MONO_TOKEN_MEMBER_REF)
 544                 g_error ("Unsupported Field Token is a MemberRef, implement me");
 545
 546         g_assert (mono_metadata_token_code (field_token) == MONO_TOKEN_FIELD_DEF);
 547
 548         return mono_class_get_field_idx (class, idx - 1);
 549 }
 550
 551 /**
 552  * mono_class_get:
 553  * @image: the image where the class resides
 554  * @type_token: the token for the class
 555  * @at: an optional pointer to return the array element type
 556  *
 557  * Returns: the MonoClass that represents @type_token in @image
 558  */
 559 MonoClass *
 560 mono_class_get (MonoImage *image, guint32 type_token)
 561 {
 562         MonoClass *class;
 563
 564         switch (type_token & 0xff000000){
 565         case MONO_TOKEN_TYPE_DEF:
 566                 if ((class = g_hash_table_lookup (image->class_cache,
 567                                                   GUINT_TO_POINTER (type_token))))
 568                         return class;
 569                 class = mono_class_create_from_typedef (image, type_token);
 570                 break;
 571         case MONO_TOKEN_TYPE_REF:
 572                 return mono_class_create_from_typeref (image, type_token);
 573         case MONO_TOKEN_TYPE_SPEC:
 574                 if ((class = g_hash_table_lookup (image->class_cache,
 575                                                   GUINT_TO_POINTER (type_token))))
 576                         return class;
 577
 578                 class = mono_class_create_from_typespec (image, type_token);
 579                 break;
 580         default:
 581                 g_assert_not_reached ();
 582         }
 583
 584         g_hash_table_insert (image->class_cache, GUINT_TO_POINTER (type_token), class);
 585
 586         return class;
 587 }
 588
 589 MonoClass *
 590 mono_class_from_name (MonoImage *image, const char* name_space, const char *name)
 591 {
 592         GHashTable *nspace_table;
 593         guint32 token;
 594
 595         nspace_table = g_hash_table_lookup (image->name_cache, name_space);
 596         if (!nspace_table)
 597                 return 0;
 598         token = GPOINTER_TO_UINT (g_hash_table_lookup (nspace_table, name));
 599
 600         if (!token)
 601                 g_error ("token not found for %s.%s in image %s", name_space, name, image->name);
 602
 603         token = MONO_TOKEN_TYPE_DEF | token;
 604
 605         return mono_class_get (image, token);
 606 }
 607
 608 /**
 609  * mono_array_element_size:
 610  * @ac: pointer to a #MonoArrayClass
 611  *
 612  * Returns: the size of single array element.
 613  */
 614 gint32
 615 mono_array_element_size (MonoArrayClass *ac)
 616 {
 617         gint32 esize;
 618
 619         esize = mono_class_instance_size (ac->element_class);
 620
 621         if (ac->element_class->valuetype)
 622                 esize -= sizeof (MonoObject);
 623
 624         return esize;
 625 }