mono/metadata/sre-encode.c

   1 /*
   2  * sre-encode.c: Routines for encoding SRE builders into a
   3  *    MonoDynamicImage and generating tokens.
   4  *
   5  *
   6  * Author:
   7  *   Paolo Molaro (lupus@ximian.com)
   8  *
   9  * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
  10  * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
  11  * Copyright 2011 Rodrigo Kumpera
  12  * Copyright 2016 Microsoft
  13  *
  14  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  15  */
  16 #include <config.h>
  17 #include <glib.h>
  18
  19 #include "mono/metadata/dynamic-image-internals.h"
  20 #include "mono/metadata/dynamic-stream-internals.h"
  21 #include "mono/metadata/object-internals.h"
  22 #include "mono/metadata/sre-internals.h"
  23 #include "mono/metadata/tabledefs.h"
  24 #include "mono/metadata/tokentype.h"
  25 #include "mono/utils/checked-build.h"
  26
  27 typedef struct {
  28         char *p;
  29         char *buf;
  30         char *end;
  31 } SigBuffer;
  32
  33 static guint32 create_typespec (MonoDynamicImage *assembly, MonoType *type);
  34 static void    encode_type (MonoDynamicImage *assembly, MonoType *type, SigBuffer *buf);
  35 static guint32 mono_image_typedef_or_ref (MonoDynamicImage *assembly, MonoType *type);
  36
  37 #define mono_type_array_get_and_resolve(array, index, error) mono_reflection_type_get_handle ((MonoReflectionType*)mono_array_get (array, gpointer, index), error)
  38
  39 static guint32
  40 mono_image_add_stream_data (MonoDynamicStream *stream, const char *data, guint32 len)
  41 {
  42         return mono_dynstream_add_data (stream, data, len);
  43 }
  44
  45 static void
  46 alloc_table (MonoDynamicTable *table, guint nrows)
  47 {
  48         mono_dynimage_alloc_table (table, nrows);
  49 }
  50
  51 static void
  52 sigbuffer_init (SigBuffer *buf, int size)
  53 {
  54         MONO_REQ_GC_NEUTRAL_MODE;
  55
  56         buf->buf = (char *)g_malloc (size);
  57         buf->p = buf->buf;
  58         buf->end = buf->buf + size;
  59 }
  60
  61 static void
  62 sigbuffer_make_room (SigBuffer *buf, int size)
  63 {
  64         MONO_REQ_GC_NEUTRAL_MODE;
  65
  66         if (buf->end - buf->p < size) {
  67                 int new_size = buf->end - buf->buf + size + 32;
  68                 char *p = (char *)g_realloc (buf->buf, new_size);
  69                 size = buf->p - buf->buf;
  70                 buf->buf = p;
  71                 buf->p = p + size;
  72                 buf->end = buf->buf + new_size;
  73         }
  74 }
  75
  76 static void
  77 sigbuffer_add_value (SigBuffer *buf, guint32 val)
  78 {
  79         MONO_REQ_GC_NEUTRAL_MODE;
  80
  81         sigbuffer_make_room (buf, 6);
  82         mono_metadata_encode_value (val, buf->p, &buf->p);
  83 }
  84
  85 static void
  86 sigbuffer_add_byte (SigBuffer *buf, guint8 val)
  87 {
  88         MONO_REQ_GC_NEUTRAL_MODE;
  89
  90         sigbuffer_make_room (buf, 1);
  91         buf->p [0] = val;
  92         buf->p++;
  93 }
  94
  95 static void
  96 sigbuffer_add_mem (SigBuffer *buf, char *p, guint32 size)
  97 {
  98         MONO_REQ_GC_NEUTRAL_MODE;
  99
 100         sigbuffer_make_room (buf, size);
 101         memcpy (buf->p, p, size);
 102         buf->p += size;
 103 }
 104
 105 static void
 106 sigbuffer_free (SigBuffer *buf)
 107 {
 108         MONO_REQ_GC_NEUTRAL_MODE;
 109
 110         g_free (buf->buf);
 111 }
 112
 113 static guint32
 114 sigbuffer_add_to_blob_cached (MonoDynamicImage *assembly, SigBuffer *buf)
 115 {
 116         MONO_REQ_GC_NEUTRAL_MODE;
 117
 118         char blob_size [8];
 119         char *b = blob_size;
 120         guint32 size = buf->p - buf->buf;
 121         /* store length */
 122         g_assert (size <= (buf->end - buf->buf));
 123         mono_metadata_encode_value (size, b, &b);
 124         return mono_dynamic_image_add_to_blob_cached (assembly, blob_size, b-blob_size, buf->buf, size);
 125 }
 126
 127
 128 static void
 129 encode_generic_class (MonoDynamicImage *assembly, MonoGenericClass *gclass, SigBuffer *buf)
 130 {
 131         MONO_REQ_GC_NEUTRAL_MODE;
 132
 133         int i;
 134         MonoGenericInst *class_inst;
 135         MonoClass *klass;
 136
 137         g_assert (gclass);
 138
 139         class_inst = gclass->context.class_inst;
 140
 141         sigbuffer_add_value (buf, MONO_TYPE_GENERICINST);
 142         klass = gclass->container_class;
 143         sigbuffer_add_value (buf, klass->byval_arg.type);
 144         sigbuffer_add_value (buf, mono_dynimage_encode_typedef_or_ref_full (assembly, &klass->byval_arg, FALSE));
 145
 146         sigbuffer_add_value (buf, class_inst->type_argc);
 147         for (i = 0; i < class_inst->type_argc; ++i)
 148                 encode_type (assembly, class_inst->type_argv [i], buf);
 149
 150 }
 151
 152 static void
 153 encode_type (MonoDynamicImage *assembly, MonoType *type, SigBuffer *buf)
 154 {
 155         MONO_REQ_GC_NEUTRAL_MODE;
 156
 157         if (!type) {
 158                 g_assert_not_reached ();
 159                 return;
 160         }
 161
 162         if (type->byref)
 163                 sigbuffer_add_value (buf, MONO_TYPE_BYREF);
 164
 165         switch (type->type){
 166         case MONO_TYPE_VOID:
 167         case MONO_TYPE_BOOLEAN:
 168         case MONO_TYPE_CHAR:
 169         case MONO_TYPE_I1:
 170         case MONO_TYPE_U1:
 171         case MONO_TYPE_I2:
 172         case MONO_TYPE_U2:
 173         case MONO_TYPE_I4:
 174         case MONO_TYPE_U4:
 175         case MONO_TYPE_I8:
 176         case MONO_TYPE_U8:
 177         case MONO_TYPE_R4:
 178         case MONO_TYPE_R8:
 179         case MONO_TYPE_I:
 180         case MONO_TYPE_U:
 181         case MONO_TYPE_STRING:
 182         case MONO_TYPE_OBJECT:
 183         case MONO_TYPE_TYPEDBYREF:
 184                 sigbuffer_add_value (buf, type->type);
 185                 break;
 186         case MONO_TYPE_PTR:
 187                 sigbuffer_add_value (buf, type->type);
 188                 encode_type (assembly, type->data.type, buf);
 189                 break;
 190         case MONO_TYPE_SZARRAY:
 191                 sigbuffer_add_value (buf, type->type);
 192                 encode_type (assembly, &type->data.klass->byval_arg, buf);
 193                 break;
 194         case MONO_TYPE_VALUETYPE:
 195         case MONO_TYPE_CLASS: {
 196                 MonoClass *k = mono_class_from_mono_type (type);
 197
 198                 if (k->generic_container) {
 199                         MonoGenericClass *gclass = mono_metadata_lookup_generic_class (k, k->generic_container->context.class_inst, TRUE);
 200                         encode_generic_class (assembly, gclass, buf);
 201                 } else {
 202                         /*
 203                          * Make sure we use the correct type.
 204                          */
 205                         sigbuffer_add_value (buf, k->byval_arg.type);
 206                         /*
 207                          * ensure only non-byref gets passed to mono_image_typedef_or_ref(),
 208                          * otherwise two typerefs could point to the same type, leading to
 209                          * verification errors.
 210                          */
 211                         sigbuffer_add_value (buf, mono_image_typedef_or_ref (assembly, &k->byval_arg));
 212                 }
 213                 break;
 214         }
 215         case MONO_TYPE_ARRAY:
 216                 sigbuffer_add_value (buf, type->type);
 217                 encode_type (assembly, &type->data.array->eklass->byval_arg, buf);
 218                 sigbuffer_add_value (buf, type->data.array->rank);
 219                 sigbuffer_add_value (buf, 0); /* FIXME: set to 0 for now */
 220                 sigbuffer_add_value (buf, 0);
 221                 break;
 222         case MONO_TYPE_GENERICINST:
 223                 encode_generic_class (assembly, type->data.generic_class, buf);
 224                 break;
 225         case MONO_TYPE_VAR:
 226         case MONO_TYPE_MVAR:
 227                 sigbuffer_add_value (buf, type->type);
 228                 sigbuffer_add_value (buf, mono_type_get_generic_param_num (type));
 229                 break;
 230         default:
 231                 g_error ("need to encode type %x", type->type);
 232         }
 233 }
 234
 235 static void
 236 encode_reflection_type (MonoDynamicImage *assembly, MonoReflectionType *type, SigBuffer *buf, MonoError *error)
 237 {
 238         MONO_REQ_GC_UNSAFE_MODE;
 239
 240         mono_error_init (error);
 241
 242         if (!type) {
 243                 sigbuffer_add_value (buf, MONO_TYPE_VOID);
 244                 return;
 245         }
 246
 247         MonoType *t = mono_reflection_type_get_handle (type, error);
 248         return_if_nok (error);
 249         encode_type (assembly, t, buf);
 250 }
 251
 252 static void
 253 encode_custom_modifiers (MonoDynamicImage *assembly, MonoArray *modreq, MonoArray *modopt, SigBuffer *buf, MonoError *error)
 254 {
 255         MONO_REQ_GC_UNSAFE_MODE;
 256
 257         int i;
 258
 259         mono_error_init (error);
 260
 261         if (modreq) {
 262                 for (i = 0; i < mono_array_length (modreq); ++i) {
 263                         MonoType *mod = mono_type_array_get_and_resolve (modreq, i, error);
 264                         return_if_nok (error);
 265                         sigbuffer_add_byte (buf, MONO_TYPE_CMOD_REQD);
 266                         sigbuffer_add_value (buf, mono_image_typedef_or_ref (assembly, mod));
 267                 }
 268         }
 269         if (modopt) {
 270                 for (i = 0; i < mono_array_length (modopt); ++i) {
 271                         MonoType *mod = mono_type_array_get_and_resolve (modopt, i, error);
 272                         return_if_nok (error);
 273                         sigbuffer_add_byte (buf, MONO_TYPE_CMOD_OPT);
 274                         sigbuffer_add_value (buf, mono_image_typedef_or_ref (assembly, mod));
 275                 }
 276         }
 277 }
 278
 279 #ifndef DISABLE_REFLECTION_EMIT
 280 guint32
 281 mono_dynimage_encode_method_signature (MonoDynamicImage *assembly, MonoMethodSignature *sig)
 282 {
 283         MONO_REQ_GC_UNSAFE_MODE;
 284
 285         SigBuffer buf;
 286         int i;
 287         guint32 nparams =  sig->param_count;
 288         guint32 idx;
 289
 290         if (!assembly->save)
 291                 return 0;
 292
 293         sigbuffer_init (&buf, 32);
 294         /*
 295          * FIXME: vararg, explicit_this, differenc call_conv values...
 296          */
 297         idx = sig->call_convention;
 298         if (sig->hasthis)
 299                 idx |= 0x20; /* hasthis */
 300         if (sig->generic_param_count)
 301                 idx |= 0x10; /* generic */
 302         sigbuffer_add_byte (&buf, idx);
 303         if (sig->generic_param_count)
 304                 sigbuffer_add_value (&buf, sig->generic_param_count);
 305         sigbuffer_add_value (&buf, nparams);
 306         encode_type (assembly, sig->ret, &buf);
 307         for (i = 0; i < nparams; ++i) {
 308                 if (i == sig->sentinelpos)
 309                         sigbuffer_add_byte (&buf, MONO_TYPE_SENTINEL);
 310                 encode_type (assembly, sig->params [i], &buf);
 311         }
 312         idx = sigbuffer_add_to_blob_cached (assembly, &buf);
 313         sigbuffer_free (&buf);
 314         return idx;
 315 }
 316 #else /* DISABLE_REFLECTION_EMIT */
 317 guint32
 318 mono_dynimage_encode_method_signature (MonoDynamicImage *assembly, MonoMethodSignature *sig)
 319 {
 320         g_assert_not_reached ();
 321         return 0;
 322 }
 323 #endif
 324
 325 guint32
 326 mono_dynimage_encode_method_builder_signature (MonoDynamicImage *assembly, ReflectionMethodBuilder *mb, MonoError *error)
 327 {
 328         MONO_REQ_GC_UNSAFE_MODE;
 329
 330         mono_error_init (error);
 331
 332         /*
 333          * FIXME: reuse code from method_encode_signature().
 334          */
 335         SigBuffer buf;
 336         int i;
 337         guint32 nparams =  mb->parameters ? mono_array_length (mb->parameters): 0;
 338         guint32 ngparams = mb->generic_params ? mono_array_length (mb->generic_params): 0;
 339         guint32 notypes = mb->opt_types ? mono_array_length (mb->opt_types): 0;
 340         guint32 idx;
 341
 342         sigbuffer_init (&buf, 32);
 343         /* LAMESPEC: all the call conv spec is foobared */
 344         idx = mb->call_conv & 0x60; /* has-this, explicit-this */
 345         if (mb->call_conv & 2)
 346                 idx |= 0x5; /* vararg */
 347         if (!(mb->attrs & METHOD_ATTRIBUTE_STATIC))
 348                 idx |= 0x20; /* hasthis */
 349         if (ngparams)
 350                 idx |= 0x10; /* generic */
 351         sigbuffer_add_byte (&buf, idx);
 352         if (ngparams)
 353                 sigbuffer_add_value (&buf, ngparams);
 354         sigbuffer_add_value (&buf, nparams + notypes);
 355         encode_custom_modifiers (assembly, mb->return_modreq, mb->return_modopt, &buf, error);
 356         if (!is_ok (error))
 357                 goto leave;
 358         encode_reflection_type (assembly, mb->rtype, &buf, error);
 359         if (!is_ok (error))
 360                 goto leave;
 361         for (i = 0; i < nparams; ++i) {
 362                 MonoArray *modreq = NULL;
 363                 MonoArray *modopt = NULL;
 364                 MonoReflectionType *pt;
 365
 366                 if (mb->param_modreq && (i < mono_array_length (mb->param_modreq)))
 367                         modreq = mono_array_get (mb->param_modreq, MonoArray*, i);
 368                 if (mb->param_modopt && (i < mono_array_length (mb->param_modopt)))
 369                         modopt = mono_array_get (mb->param_modopt, MonoArray*, i);
 370                 encode_custom_modifiers (assembly, modreq, modopt, &buf, error);
 371                 if (!is_ok (error))
 372                         goto leave;
 373                 pt = mono_array_get (mb->parameters, MonoReflectionType*, i);
 374                 encode_reflection_type (assembly, pt, &buf, error);
 375                 if (!is_ok (error))
 376                         goto leave;
 377         }
 378         if (notypes)
 379                 sigbuffer_add_byte (&buf, MONO_TYPE_SENTINEL);
 380         for (i = 0; i < notypes; ++i) {
 381                 MonoReflectionType *pt;
 382
 383                 pt = mono_array_get (mb->opt_types, MonoReflectionType*, i);
 384                 encode_reflection_type (assembly, pt, &buf, error);
 385                 if (!is_ok (error))
 386                         goto leave;
 387         }
 388
 389         idx = sigbuffer_add_to_blob_cached (assembly, &buf);
 390 leave:
 391         sigbuffer_free (&buf);
 392         return idx;
 393 }
 394
 395 guint32
 396 mono_dynimage_encode_locals (MonoDynamicImage *assembly, MonoReflectionILGen *ilgen, MonoError *error)
 397 {
 398         MONO_REQ_GC_UNSAFE_MODE;
 399
 400         mono_error_init (error);
 401
 402         MonoDynamicTable *table;
 403         guint32 *values;
 404         guint32 idx, sig_idx;
 405         guint nl = mono_array_length (ilgen->locals);
 406         SigBuffer buf;
 407         int i;
 408
 409         sigbuffer_init (&buf, 32);
 410         sigbuffer_add_value (&buf, 0x07);
 411         sigbuffer_add_value (&buf, nl);
 412         for (i = 0; i < nl; ++i) {
 413                 MonoReflectionLocalBuilder *lb = mono_array_get (ilgen->locals, MonoReflectionLocalBuilder*, i);
 414
 415                 if (lb->is_pinned)
 416                         sigbuffer_add_value (&buf, MONO_TYPE_PINNED);
 417
 418                 encode_reflection_type (assembly, (MonoReflectionType*)lb->type, &buf, error);
 419                 if (!is_ok (error)) {
 420                         sigbuffer_free (&buf);
 421                         return 0;
 422                 }
 423         }
 424         sig_idx = sigbuffer_add_to_blob_cached (assembly, &buf);
 425         sigbuffer_free (&buf);
 426
 427         if (assembly->standalonesig_cache == NULL)
 428                 assembly->standalonesig_cache = g_hash_table_new (NULL, NULL);
 429         idx = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->standalonesig_cache, GUINT_TO_POINTER (sig_idx)));
 430         if (idx)
 431                 return idx;
 432
 433         table = &assembly->tables [MONO_TABLE_STANDALONESIG];
 434         idx = table->next_idx ++;
 435         table->rows ++;
 436         alloc_table (table, table->rows);
 437         values = table->values + idx * MONO_STAND_ALONE_SIGNATURE_SIZE;
 438
 439         values [MONO_STAND_ALONE_SIGNATURE] = sig_idx;
 440
 441         g_hash_table_insert (assembly->standalonesig_cache, GUINT_TO_POINTER (sig_idx), GUINT_TO_POINTER (idx));
 442
 443         return idx;
 444 }
 445
 446
 447 /*
 448  * Copy len * nelem bytes from val to dest, swapping bytes to LE if necessary.
 449  * dest may be misaligned.
 450  */
 451 static void
 452 swap_with_size (char *dest, const char* val, int len, int nelem) {
 453         MONO_REQ_GC_NEUTRAL_MODE;
 454 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
 455         int elem;
 456
 457         for (elem = 0; elem < nelem; ++elem) {
 458                 switch (len) {
 459                 case 1:
 460                         *dest = *val;
 461                         break;
 462                 case 2:
 463                         dest [0] = val [1];
 464                         dest [1] = val [0];
 465                         break;
 466                 case 4:
 467                         dest [0] = val [3];
 468                         dest [1] = val [2];
 469                         dest [2] = val [1];
 470                         dest [3] = val [0];
 471                         break;
 472                 case 8:
 473                         dest [0] = val [7];
 474                         dest [1] = val [6];
 475                         dest [2] = val [5];
 476                         dest [3] = val [4];
 477                         dest [4] = val [3];
 478                         dest [5] = val [2];
 479                         dest [6] = val [1];
 480                         dest [7] = val [0];
 481                         break;
 482                 default:
 483                         g_assert_not_reached ();
 484                 }
 485                 dest += len;
 486                 val += len;
 487         }
 488 #else
 489         memcpy (dest, val, len * nelem);
 490 #endif
 491 }
 492
 493
 494 guint32
 495 mono_dynimage_encode_constant (MonoDynamicImage *assembly, MonoObject *val, MonoTypeEnum *ret_type)
 496 {
 497         MONO_REQ_GC_UNSAFE_MODE;
 498
 499         char blob_size [64];
 500         char *b = blob_size;
 501         char *box_val;
 502         char* buf;
 503         guint32 idx = 0, len = 0, dummy = 0;
 504
 505         buf = (char *)g_malloc (64);
 506         if (!val) {
 507                 *ret_type = MONO_TYPE_CLASS;
 508                 len = 4;
 509                 box_val = (char*)&dummy;
 510         } else {
 511                 box_val = ((char*)val) + sizeof (MonoObject);
 512                 *ret_type = val->vtable->klass->byval_arg.type;
 513         }
 514 handle_enum:
 515         switch (*ret_type) {
 516         case MONO_TYPE_BOOLEAN:
 517         case MONO_TYPE_U1:
 518         case MONO_TYPE_I1:
 519                 len = 1;
 520                 break;
 521         case MONO_TYPE_CHAR:
 522         case MONO_TYPE_U2:
 523         case MONO_TYPE_I2:
 524                 len = 2;
 525                 break;
 526         case MONO_TYPE_U4:
 527         case MONO_TYPE_I4:
 528         case MONO_TYPE_R4:
 529                 len = 4;
 530                 break;
 531         case MONO_TYPE_U8:
 532         case MONO_TYPE_I8:
 533                 len = 8;
 534                 break;
 535         case MONO_TYPE_R8:
 536                 len = 8;
 537                 break;
 538         case MONO_TYPE_VALUETYPE: {
 539                 MonoClass *klass = val->vtable->klass;
 540
 541                 if (klass->enumtype) {
 542                         *ret_type = mono_class_enum_basetype (klass)->type;
 543                         goto handle_enum;
 544                 } else if (mono_is_corlib_image (klass->image) && strcmp (klass->name_space, "System") == 0 && strcmp (klass->name, "DateTime") == 0) {
 545                         len = 8;
 546                 } else
 547                         g_error ("we can't encode valuetypes, we should have never reached this line");
 548                 break;
 549         }
 550         case MONO_TYPE_CLASS:
 551                 break;
 552         case MONO_TYPE_STRING: {
 553                 MonoString *str = (MonoString*)val;
 554                 /* there is no signature */
 555                 len = str->length * 2;
 556                 mono_metadata_encode_value (len, b, &b);
 557 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
 558                 {
 559                         char *swapped = g_malloc (2 * mono_string_length (str));
 560                         const char *p = (const char*)mono_string_chars (str);
 561
 562                         swap_with_size (swapped, p, 2, mono_string_length (str));
 563                         idx = mono_dynamic_image_add_to_blob_cached (assembly, blob_size, b-blob_size, swapped, len);
 564                         g_free (swapped);
 565                 }
 566 #else
 567                 idx = mono_dynamic_image_add_to_blob_cached (assembly, blob_size, b-blob_size, (char*)mono_string_chars (str), len);
 568 #endif
 569
 570                 g_free (buf);
 571                 return idx;
 572         }
 573         case MONO_TYPE_GENERICINST:
 574                 *ret_type = val->vtable->klass->generic_class->container_class->byval_arg.type;
 575                 goto handle_enum;
 576         default:
 577                 g_error ("we don't encode constant type 0x%02x yet", *ret_type);
 578         }
 579
 580         /* there is no signature */
 581         mono_metadata_encode_value (len, b, &b);
 582 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
 583         idx = mono_image_add_stream_data (&assembly->blob, blob_size, b-blob_size);
 584         swap_with_size (blob_size, box_val, len, 1);
 585         mono_image_add_stream_data (&assembly->blob, blob_size, len);
 586 #else
 587         idx = mono_dynamic_image_add_to_blob_cached (assembly, blob_size, b-blob_size, box_val, len);
 588 #endif
 589
 590         g_free (buf);
 591         return idx;
 592 }
 593
 594 guint32
 595 mono_dynimage_encode_field_signature (MonoDynamicImage *assembly, MonoReflectionFieldBuilder *fb, MonoError *error)
 596 {
 597         MONO_REQ_GC_UNSAFE_MODE;
 598
 599         mono_error_init (error);
 600
 601         SigBuffer buf;
 602         guint32 idx;
 603         guint32 typespec = 0;
 604         MonoType *type;
 605         MonoClass *klass;
 606
 607         type = mono_reflection_type_get_handle ((MonoReflectionType*)fb->type, error);
 608         return_val_if_nok (error, 0);
 609         klass = mono_class_from_mono_type (type);
 610
 611         sigbuffer_init (&buf, 32);
 612
 613         sigbuffer_add_value (&buf, 0x06);
 614         encode_custom_modifiers (assembly, fb->modreq, fb->modopt, &buf, error);
 615         if (!is_ok (error))
 616                 goto fail;
 617         /* encode custom attributes before the type */
 618
 619         if (klass->generic_container)
 620                 typespec = create_typespec (assembly, type);
 621
 622         if (typespec) {
 623                 MonoGenericClass *gclass;
 624                 gclass = mono_metadata_lookup_generic_class (klass, klass->generic_container->context.class_inst, TRUE);
 625                 encode_generic_class (assembly, gclass, &buf);
 626         } else {
 627                 encode_type (assembly, type, &buf);
 628         }
 629         idx = sigbuffer_add_to_blob_cached (assembly, &buf);
 630         sigbuffer_free (&buf);
 631         return idx;
 632 fail:
 633         sigbuffer_free (&buf);
 634         return 0;
 635 }
 636
 637 #ifndef DISABLE_REFLECTION_EMIT
 638 /*field_image is the image to which the eventual custom mods have been encoded against*/
 639 guint32
 640 mono_dynimage_encode_fieldref_signature (MonoDynamicImage *assembly, MonoImage *field_image, MonoType *type)
 641 {
 642         MONO_REQ_GC_NEUTRAL_MODE;
 643
 644         SigBuffer buf;
 645         guint32 idx, i, token;
 646
 647         if (!assembly->save)
 648                 return 0;
 649
 650         sigbuffer_init (&buf, 32);
 651
 652         sigbuffer_add_value (&buf, 0x06);
 653         /* encode custom attributes before the type */
 654         if (type->num_mods) {
 655                 for (i = 0; i < type->num_mods; ++i) {
 656                         if (field_image) {
 657                                 MonoError error;
 658                                 MonoClass *klass = mono_class_get_checked (field_image, type->modifiers [i].token, &error);
 659                                 g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
 660
 661                                 token = mono_image_typedef_or_ref (assembly, &klass->byval_arg);
 662                         } else {
 663                                 token = type->modifiers [i].token;
 664                         }
 665
 666                         if (type->modifiers [i].required)
 667                                 sigbuffer_add_byte (&buf, MONO_TYPE_CMOD_REQD);
 668                         else
 669                                 sigbuffer_add_byte (&buf, MONO_TYPE_CMOD_OPT);
 670
 671                         sigbuffer_add_value (&buf, token);
 672                 }
 673         }
 674         encode_type (assembly, type, &buf);
 675         idx = sigbuffer_add_to_blob_cached (assembly, &buf);
 676         sigbuffer_free (&buf);
 677         return idx;
 678 }
 679 #else /* DISABLE_REFLECTION_EMIT */
 680 guint32
 681 mono_dynimage_encode_fieldref_signature (MonoDynamicImage *assembly, MonoImage *field_image, MonoType *type)
 682 {
 683         g_assert_not_reached ();
 684         return 0;
 685 }
 686 #endif /* DISABLE_REFLECTION_EMIT */
 687
 688 static guint32
 689 create_typespec (MonoDynamicImage *assembly, MonoType *type)
 690 {
 691         MONO_REQ_GC_NEUTRAL_MODE;
 692
 693         MonoDynamicTable *table;
 694         guint32 *values;
 695         guint32 token;
 696         SigBuffer buf;
 697
 698         if ((token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->typespec, type))))
 699                 return token;
 700
 701         sigbuffer_init (&buf, 32);
 702         switch (type->type) {
 703         case MONO_TYPE_FNPTR:
 704         case MONO_TYPE_PTR:
 705         case MONO_TYPE_SZARRAY:
 706         case MONO_TYPE_ARRAY:
 707         case MONO_TYPE_VAR:
 708         case MONO_TYPE_MVAR:
 709         case MONO_TYPE_GENERICINST:
 710                 encode_type (assembly, type, &buf);
 711                 break;
 712         case MONO_TYPE_CLASS:
 713         case MONO_TYPE_VALUETYPE: {
 714                 MonoClass *k = mono_class_from_mono_type (type);
 715                 if (!k || !k->generic_container) {
 716                         sigbuffer_free (&buf);
 717                         return 0;
 718                 }
 719                 encode_type (assembly, type, &buf);
 720                 break;
 721         }
 722         default:
 723                 sigbuffer_free (&buf);
 724                 return 0;
 725         }
 726
 727         table = &assembly->tables [MONO_TABLE_TYPESPEC];
 728         if (assembly->save) {
 729                 token = sigbuffer_add_to_blob_cached (assembly, &buf);
 730                 alloc_table (table, table->rows + 1);
 731                 values = table->values + table->next_idx * MONO_TYPESPEC_SIZE;
 732                 values [MONO_TYPESPEC_SIGNATURE] = token;
 733         }
 734         sigbuffer_free (&buf);
 735
 736         token = MONO_TYPEDEFORREF_TYPESPEC | (table->next_idx << MONO_TYPEDEFORREF_BITS);
 737         g_hash_table_insert (assembly->typespec, type, GUINT_TO_POINTER(token));
 738         table->next_idx ++;
 739         return token;
 740 }
 741
 742 guint32
 743 mono_dynimage_encode_typedef_or_ref_full (MonoDynamicImage *assembly, MonoType *type, gboolean try_typespec)
 744 {
 745         MONO_REQ_GC_UNSAFE_MODE;
 746
 747         MonoDynamicTable *table;
 748         guint32 *values;
 749         guint32 token, scope, enclosing;
 750         MonoClass *klass;
 751
 752         /* if the type requires a typespec, we must try that first*/
 753         if (try_typespec && (token = create_typespec (assembly, type)))
 754                 return token;
 755         token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->typeref, type));
 756         if (token)
 757                 return token;
 758         klass = mono_class_from_mono_type (type);
 759         if (!klass)
 760                 klass = mono_class_from_mono_type (type);
 761
 762         /*
 763          * If it's in the same module and not a generic type parameter:
 764          */
 765         if ((klass->image == &assembly->image) && (type->type != MONO_TYPE_VAR) &&
 766                         (type->type != MONO_TYPE_MVAR)) {
 767                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info (klass);
 768                 token = MONO_TYPEDEFORREF_TYPEDEF | (tb->table_idx << MONO_TYPEDEFORREF_BITS);
 769                 mono_dynamic_image_register_token (assembly, token, (MonoObject *)mono_class_get_ref_info (klass));
 770                 return token;
 771         }
 772
 773         if (klass->nested_in) {
 774                 enclosing = mono_dynimage_encode_typedef_or_ref_full (assembly, &klass->nested_in->byval_arg, FALSE);
 775                 /* get the typeref idx of the enclosing type */
 776                 enclosing >>= MONO_TYPEDEFORREF_BITS;
 777                 scope = (enclosing << MONO_RESOLUTION_SCOPE_BITS) | MONO_RESOLUTION_SCOPE_TYPEREF;
 778         } else {
 779                 scope = mono_reflection_resolution_scope_from_image (assembly, klass->image);
 780         }
 781         table = &assembly->tables [MONO_TABLE_TYPEREF];
 782         if (assembly->save) {
 783                 alloc_table (table, table->rows + 1);
 784                 values = table->values + table->next_idx * MONO_TYPEREF_SIZE;
 785                 values [MONO_TYPEREF_SCOPE] = scope;
 786                 values [MONO_TYPEREF_NAME] = mono_dynstream_insert_string (&assembly->sheap, klass->name);
 787                 values [MONO_TYPEREF_NAMESPACE] = mono_dynstream_insert_string (&assembly->sheap, klass->name_space);
 788         }
 789         token = MONO_TYPEDEFORREF_TYPEREF | (table->next_idx << MONO_TYPEDEFORREF_BITS); /* typeref */
 790         g_hash_table_insert (assembly->typeref, type, GUINT_TO_POINTER(token));
 791         table->next_idx ++;
 792         mono_dynamic_image_register_token (assembly, token, (MonoObject *)mono_class_get_ref_info (klass));
 793         return token;
 794 }
 795
 796 /*
 797  * Despite the name, we handle also TypeSpec (with the above helper).
 798  */
 799 static guint32
 800 mono_image_typedef_or_ref (MonoDynamicImage *assembly, MonoType *type)
 801 {
 802         return mono_dynimage_encode_typedef_or_ref_full (assembly, type, TRUE);
 803 }
 804
 805 guint32
 806 mono_dynimage_encode_generic_method_sig (MonoDynamicImage *assembly, MonoGenericContext *context)
 807 {
 808         SigBuffer buf;
 809         int i;
 810         guint32 nparams = context->method_inst->type_argc;
 811         guint32 idx;
 812
 813         if (!assembly->save)
 814                 return 0;
 815
 816         sigbuffer_init (&buf, 32);
 817         /*
 818          * FIXME: vararg, explicit_this, differenc call_conv values...
 819          */
 820         sigbuffer_add_value (&buf, 0xa); /* FIXME FIXME FIXME */
 821         sigbuffer_add_value (&buf, nparams);
 822
 823         for (i = 0; i < nparams; i++)
 824                 encode_type (assembly, context->method_inst->type_argv [i], &buf);
 825
 826         idx = sigbuffer_add_to_blob_cached (assembly, &buf);
 827         sigbuffer_free (&buf);
 828         return idx;
 829 }
 830
 831 #ifndef DISABLE_REFLECTION_EMIT
 832 guint32
 833 mono_dynimage_encode_reflection_sighelper (MonoDynamicImage *assembly, MonoReflectionSigHelper *helper, MonoError *error)
 834 {
 835         SigBuffer buf;
 836         guint32 nargs;
 837         guint32 i, idx;
 838
 839         mono_error_init (error);
 840
 841         if (!assembly->save)
 842                 return 0;
 843
 844         /* FIXME: this means SignatureHelper.SignatureHelpType.HELPER_METHOD */
 845         g_assert (helper->type == 2);
 846
 847         if (helper->arguments)
 848                 nargs = mono_array_length (helper->arguments);
 849         else
 850                 nargs = 0;
 851
 852         sigbuffer_init (&buf, 32);
 853
 854         /* Encode calling convention */
 855         /* Change Any to Standard */
 856         if ((helper->call_conv & 0x03) == 0x03)
 857                 helper->call_conv = 0x01;
 858         /* explicit_this implies has_this */
 859         if (helper->call_conv & 0x40)
 860                 helper->call_conv &= 0x20;
 861
 862         if (helper->call_conv == 0) { /* Unmanaged */
 863                 idx = helper->unmanaged_call_conv - 1;
 864         } else {
 865                 /* Managed */
 866                 idx = helper->call_conv & 0x60; /* has_this + explicit_this */
 867                 if (helper->call_conv & 0x02) /* varargs */
 868                         idx += 0x05;
 869         }
 870
 871         sigbuffer_add_byte (&buf, idx);
 872         sigbuffer_add_value (&buf, nargs);
 873         encode_reflection_type (assembly, helper->return_type, &buf, error);
 874         if (!is_ok (error))
 875                 goto fail;
 876         for (i = 0; i < nargs; ++i) {
 877                 MonoArray *modreqs = NULL;
 878                 MonoArray *modopts = NULL;
 879                 MonoReflectionType *pt;
 880
 881                 if (helper->modreqs && (i < mono_array_length (helper->modreqs)))
 882                         modreqs = mono_array_get (helper->modreqs, MonoArray*, i);
 883                 if (helper->modopts && (i < mono_array_length (helper->modopts)))
 884                         modopts = mono_array_get (helper->modopts, MonoArray*, i);
 885
 886                 encode_custom_modifiers (assembly, modreqs, modopts, &buf, error);
 887                 if (!is_ok (error))
 888                         goto fail;
 889                 pt = mono_array_get (helper->arguments, MonoReflectionType*, i);
 890                 encode_reflection_type (assembly, pt, &buf, error);
 891                 if (!is_ok (error))
 892                         goto fail;
 893         }
 894         idx = sigbuffer_add_to_blob_cached (assembly, &buf);
 895         sigbuffer_free (&buf);
 896
 897         return idx;
 898 fail:
 899         sigbuffer_free (&buf);
 900         return 0;
 901 }
 902 #else /* DISABLE_REFLECTION_EMIT */
 903 guint32
 904 mono_dynimage_encode_reflection_sighelper (MonoDynamicImage *assembly, MonoReflectionSigHelper *helper, MonoError *error)
 905 {
 906         g_assert_not_reached ();
 907         return 0;
 908 }
 909 #endif /* DISABLE_REFLECTION_EMIT */
 910
 911 static MonoArray *
 912 reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig, MonoError *error)
 913 {
 914         MonoReflectionModuleBuilder *module = sig->module;
 915         MonoDynamicImage *assembly = module != NULL ? module->dynamic_image : NULL;
 916         guint32 na = sig->arguments ? mono_array_length (sig->arguments) : 0;
 917         guint32 buflen, i;
 918         MonoArray *result;
 919         SigBuffer buf;
 920
 921         mono_error_init (error);
 922
 923         sigbuffer_init (&buf, 32);
 924
 925         sigbuffer_add_value (&buf, 0x07);
 926         sigbuffer_add_value (&buf, na);
 927         if (assembly != NULL){
 928                 for (i = 0; i < na; ++i) {
 929                         MonoReflectionType *type = mono_array_get (sig->arguments, MonoReflectionType*, i);
 930                         encode_reflection_type (assembly, type, &buf, error);
 931                         if (!is_ok (error)) goto fail;
 932                 }
 933         }
 934
 935         buflen = buf.p - buf.buf;
 936         result = mono_array_new_checked (mono_domain_get (), mono_defaults.byte_class, buflen, error);
 937         if (!is_ok (error)) goto fail;
 938         memcpy (mono_array_addr (result, char, 0), buf.buf, buflen);
 939         sigbuffer_free (&buf);
 940         return result;
 941 fail:
 942         sigbuffer_free (&buf);
 943         return NULL;
 944 }
 945
 946 static MonoArray *
 947 reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig, MonoError *error)
 948 {
 949         MonoDynamicImage *assembly = sig->module->dynamic_image;
 950         guint32 na = sig->arguments ? mono_array_length (sig->arguments) : 0;
 951         guint32 buflen, i;
 952         MonoArray *result;
 953         SigBuffer buf;
 954
 955         mono_error_init (error);
 956
 957         sigbuffer_init (&buf, 32);
 958
 959         sigbuffer_add_value (&buf, 0x06);
 960         for (i = 0; i < na; ++i) {
 961                 MonoReflectionType *type = mono_array_get (sig->arguments, MonoReflectionType*, i);
 962                 encode_reflection_type (assembly, type, &buf, error);
 963                 if (!is_ok (error))
 964                         goto fail;
 965         }
 966
 967         buflen = buf.p - buf.buf;
 968         result = mono_array_new_checked (mono_domain_get (), mono_defaults.byte_class, buflen, error);
 969         if (!is_ok (error)) goto fail;
 970         memcpy (mono_array_addr (result, char, 0), buf.buf, buflen);
 971         sigbuffer_free (&buf);
 972
 973         return result;
 974 fail:
 975         sigbuffer_free (&buf);
 976         return NULL;
 977 }
 978
 979 static char*
 980 type_get_fully_qualified_name (MonoType *type)
 981 {
 982         MONO_REQ_GC_NEUTRAL_MODE;
 983
 984         return mono_type_get_name_full (type, MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED);
 985 }
 986
 987 #ifndef DISABLE_REFLECTION_EMIT_SAVE
 988 guint32
 989 mono_dynimage_save_encode_marshal_blob (MonoDynamicImage *assembly, MonoReflectionMarshal *minfo, MonoError *error)
 990 {
 991         MONO_REQ_GC_UNSAFE_MODE;
 992
 993         mono_error_init (error);
 994
 995         char *str;
 996         SigBuffer buf;
 997         guint32 idx, len;
 998
 999         sigbuffer_init (&buf, 32);
1000
1001         sigbuffer_add_value (&buf, minfo->type);
1002
1003         switch (minfo->type) {
1004         case MONO_NATIVE_BYVALTSTR:
1005         case MONO_NATIVE_BYVALARRAY:
1006                 sigbuffer_add_value (&buf, minfo->count);
1007                 break;
1008         case MONO_NATIVE_LPARRAY:
1009                 if (minfo->eltype || minfo->has_size) {
1010                         sigbuffer_add_value (&buf, minfo->eltype);
1011                         if (minfo->has_size) {
1012                                 sigbuffer_add_value (&buf, minfo->param_num != -1? minfo->param_num: 0);
1013                                 sigbuffer_add_value (&buf, minfo->count != -1? minfo->count: 0);
1014
1015                                 /* LAMESPEC: ElemMult is undocumented */
1016                                 sigbuffer_add_value (&buf, minfo->param_num != -1? 1: 0);
1017                         }
1018                 }
1019                 break;
1020         case MONO_NATIVE_SAFEARRAY:
1021                 if (minfo->eltype)
1022                         sigbuffer_add_value (&buf, minfo->eltype);
1023                 break;
1024         case MONO_NATIVE_CUSTOM:
1025                 if (minfo->guid) {
1026                         str = mono_string_to_utf8_checked (minfo->guid, error);
1027                         if (!is_ok (error)) {
1028                                 sigbuffer_free (&buf);
1029                                 return 0;
1030                         }
1031                         len = strlen (str);
1032                         sigbuffer_add_value (&buf, len);
1033                         sigbuffer_add_mem (&buf, str, len);
1034                         g_free (str);
1035                 } else {
1036                         sigbuffer_add_value (&buf, 0);
1037                 }
1038                 /* native type name */
1039                 sigbuffer_add_value (&buf, 0);
1040                 /* custom marshaler type name */
1041                 if (minfo->marshaltype || minfo->marshaltyperef) {
1042                         if (minfo->marshaltyperef) {
1043                                 MonoType *marshaltype = mono_reflection_type_get_handle ((MonoReflectionType*)minfo->marshaltyperef, error);
1044                                 if (!is_ok (error)) {
1045                                         sigbuffer_free (&buf);
1046                                         return 0;
1047                                 }
1048                                 str = type_get_fully_qualified_name (marshaltype);
1049                         } else {
1050                                 str = mono_string_to_utf8_checked (minfo->marshaltype, error);
1051                                 if (!is_ok (error)) {
1052                                         sigbuffer_free (&buf);
1053                                         return 0;
1054                                 }
1055                         }
1056                         len = strlen (str);
1057                         sigbuffer_add_value (&buf, len);
1058                         sigbuffer_add_mem (&buf, str, len);
1059                         g_free (str);
1060                 } else {
1061                         /* FIXME: Actually a bug, since this field is required.  Punting for now ... */
1062                         sigbuffer_add_value (&buf, 0);
1063                 }
1064                 if (minfo->mcookie) {
1065                         str = mono_string_to_utf8_checked (minfo->mcookie, error);
1066                         if (!is_ok (error)) {
1067                                 sigbuffer_free (&buf);
1068                                 return 0;
1069                         }
1070                         len = strlen (str);
1071                         sigbuffer_add_value (&buf, len);
1072                         sigbuffer_add_mem (&buf, str, len);
1073                         g_free (str);
1074                 } else {
1075                         sigbuffer_add_value (&buf, 0);
1076                 }
1077                 break;
1078         default:
1079                 break;
1080         }
1081         idx = sigbuffer_add_to_blob_cached (assembly, &buf);
1082         sigbuffer_free (&buf);
1083         return idx;
1084 }
1085
1086 guint32
1087 mono_dynimage_save_encode_property_signature (MonoDynamicImage *assembly, MonoReflectionPropertyBuilder *fb, MonoError *error)
1088 {
1089         MONO_REQ_GC_UNSAFE_MODE;
1090
1091         mono_error_init (error);
1092
1093         SigBuffer buf;
1094         guint32 nparams = 0;
1095         MonoReflectionMethodBuilder *mb = fb->get_method;
1096         MonoReflectionMethodBuilder *smb = fb->set_method;
1097         guint32 idx, i;
1098
1099         if (mb && mb->parameters)
1100                 nparams = mono_array_length (mb->parameters);
1101         if (!mb && smb && smb->parameters)
1102                 nparams = mono_array_length (smb->parameters) - 1;
1103         sigbuffer_init (&buf, 32);
1104         if (fb->call_conv & 0x20)
1105                 sigbuffer_add_byte (&buf, 0x28);
1106         else
1107                 sigbuffer_add_byte (&buf, 0x08);
1108         sigbuffer_add_value (&buf, nparams);
1109         if (mb) {
1110                 encode_reflection_type (assembly, (MonoReflectionType*)mb->rtype, &buf, error);
1111                 if (!is_ok (error))
1112                         goto fail;
1113                 for (i = 0; i < nparams; ++i) {
1114                         MonoReflectionType *pt = mono_array_get (mb->parameters, MonoReflectionType*, i);
1115                         encode_reflection_type (assembly, pt, &buf, error);
1116                         if (!is_ok (error))
1117                                 goto fail;
1118                 }
1119         } else if (smb && smb->parameters) {
1120                 /* the property type is the last param */
1121                 encode_reflection_type (assembly, mono_array_get (smb->parameters, MonoReflectionType*, nparams), &buf, error);
1122                 if (!is_ok (error))
1123                         goto fail;
1124
1125                 for (i = 0; i < nparams; ++i) {
1126                         MonoReflectionType *pt = mono_array_get (smb->parameters, MonoReflectionType*, i);
1127                         encode_reflection_type (assembly, pt, &buf, error);
1128                         if (!is_ok (error))
1129                                 goto fail;
1130                 }
1131         } else {
1132                 encode_reflection_type (assembly, (MonoReflectionType*)fb->type, &buf, error);
1133                 if (!is_ok (error))
1134                         goto fail;
1135         }
1136
1137         idx = sigbuffer_add_to_blob_cached (assembly, &buf);
1138         sigbuffer_free (&buf);
1139         return idx;
1140 fail:
1141         sigbuffer_free (&buf);
1142         return 0;
1143 }
1144
1145
1146 #else /*DISABLE_REFLECTION_EMIT_SAVE*/
1147 guint32
1148 mono_dynimage_save_encode_marshal_blob (MonoDynamicImage *assembly, MonoReflectionMarshal *minfo, MonoError *error)
1149 {
1150         g_assert_not_reached ();
1151         return 0;
1152 }
1153
1154 guint32
1155 mono_dynimage_save_encode_property_signature (MonoDynamicImage *assembly, MonoReflectionPropertyBuilder *fb, MonoError *error)
1156 {
1157         g_assert_not_reached ();
1158         return 0;
1159 }
1160 #endif /*DISABLE_REFLECTION_EMIT_SAVE*/
1161
1162 #ifndef DISABLE_REFLECTION_EMIT
1163 MonoArray *
1164 ves_icall_SignatureHelper_get_signature_local (MonoReflectionSigHelper *sig)
1165 {
1166         MonoError error;
1167         MonoArray *result = reflection_sighelper_get_signature_local (sig, &error);
1168         mono_error_set_pending_exception (&error);
1169         return result;
1170 }
1171
1172 MonoArray *
1173 ves_icall_SignatureHelper_get_signature_field (MonoReflectionSigHelper *sig)
1174 {
1175         MonoError error;
1176         MonoArray *result = reflection_sighelper_get_signature_field (sig, &error);
1177         mono_error_set_pending_exception (&error);
1178         return result;
1179 }
1180 #else /* DISABLE_REFLECTION_EMIT */
1181 MonoArray *
1182 ves_icall_SignatureHelper_get_signature_local (MonoReflectionSigHelper *sig)
1183 {
1184         g_assert_not_reached ();
1185         return NULL;
1186 }
1187
1188 MonoArray *
1189 ves_icall_SignatureHelper_get_signature_field (MonoReflectionSigHelper *sig)
1190 {
1191         g_assert_not_reached ();
1192         return NULL;
1193 }
1194
1195 #endif /* DISABLE_REFLECTION_EMIT */