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 (mono_class_is_gtd (k)) {
 199                         MonoGenericClass *gclass = mono_metadata_lookup_generic_class (k, mono_class_get_generic_container (k)->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 = mono_class_get_generic_class (val->vtable->klass)->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 (mono_class_is_gtd (klass))
 620                 typespec = create_typespec (assembly, type);
 621
 622         if (typespec) {
 623                 MonoGenericClass *gclass;
 624                 gclass = mono_metadata_lookup_generic_class (klass, mono_class_get_generic_container (klass)->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 || !mono_class_is_gtd (k)) {
 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
 760         /*
 761          * If it's in the same module and not a generic type parameter:
 762          */
 763         if ((klass->image == &assembly->image) && (type->type != MONO_TYPE_VAR) &&
 764                         (type->type != MONO_TYPE_MVAR)) {
 765                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info (klass);
 766                 token = MONO_TYPEDEFORREF_TYPEDEF | (tb->table_idx << MONO_TYPEDEFORREF_BITS);
 767                 mono_dynamic_image_register_token (assembly, token, (MonoObject *)mono_class_get_ref_info (klass));
 768                 return token;
 769         }
 770
 771         if (klass->nested_in) {
 772                 enclosing = mono_dynimage_encode_typedef_or_ref_full (assembly, &klass->nested_in->byval_arg, FALSE);
 773                 /* get the typeref idx of the enclosing type */
 774                 enclosing >>= MONO_TYPEDEFORREF_BITS;
 775                 scope = (enclosing << MONO_RESOLUTION_SCOPE_BITS) | MONO_RESOLUTION_SCOPE_TYPEREF;
 776         } else {
 777                 scope = mono_reflection_resolution_scope_from_image (assembly, klass->image);
 778         }
 779         table = &assembly->tables [MONO_TABLE_TYPEREF];
 780         if (assembly->save) {
 781                 alloc_table (table, table->rows + 1);
 782                 values = table->values + table->next_idx * MONO_TYPEREF_SIZE;
 783                 values [MONO_TYPEREF_SCOPE] = scope;
 784                 values [MONO_TYPEREF_NAME] = mono_dynstream_insert_string (&assembly->sheap, klass->name);
 785                 values [MONO_TYPEREF_NAMESPACE] = mono_dynstream_insert_string (&assembly->sheap, klass->name_space);
 786         }
 787         token = MONO_TYPEDEFORREF_TYPEREF | (table->next_idx << MONO_TYPEDEFORREF_BITS); /* typeref */
 788         g_hash_table_insert (assembly->typeref, type, GUINT_TO_POINTER(token));
 789         table->next_idx ++;
 790         mono_dynamic_image_register_token (assembly, token, (MonoObject *)mono_class_get_ref_info (klass));
 791         return token;
 792 }
 793
 794 /*
 795  * Despite the name, we handle also TypeSpec (with the above helper).
 796  */
 797 static guint32
 798 mono_image_typedef_or_ref (MonoDynamicImage *assembly, MonoType *type)
 799 {
 800         return mono_dynimage_encode_typedef_or_ref_full (assembly, type, TRUE);
 801 }
 802
 803 guint32
 804 mono_dynimage_encode_generic_method_sig (MonoDynamicImage *assembly, MonoGenericContext *context)
 805 {
 806         SigBuffer buf;
 807         int i;
 808         guint32 nparams = context->method_inst->type_argc;
 809         guint32 idx;
 810
 811         if (!assembly->save)
 812                 return 0;
 813
 814         sigbuffer_init (&buf, 32);
 815         /*
 816          * FIXME: vararg, explicit_this, differenc call_conv values...
 817          */
 818         sigbuffer_add_value (&buf, 0xa); /* FIXME FIXME FIXME */
 819         sigbuffer_add_value (&buf, nparams);
 820
 821         for (i = 0; i < nparams; i++)
 822                 encode_type (assembly, context->method_inst->type_argv [i], &buf);
 823
 824         idx = sigbuffer_add_to_blob_cached (assembly, &buf);
 825         sigbuffer_free (&buf);
 826         return idx;
 827 }
 828
 829 #ifndef DISABLE_REFLECTION_EMIT
 830 guint32
 831 mono_dynimage_encode_reflection_sighelper (MonoDynamicImage *assembly, MonoReflectionSigHelper *helper, MonoError *error)
 832 {
 833         SigBuffer buf;
 834         guint32 nargs;
 835         guint32 i, idx;
 836
 837         mono_error_init (error);
 838
 839         if (!assembly->save)
 840                 return 0;
 841
 842         /* FIXME: this means SignatureHelper.SignatureHelpType.HELPER_METHOD */
 843         g_assert (helper->type == 2);
 844
 845         if (helper->arguments)
 846                 nargs = mono_array_length (helper->arguments);
 847         else
 848                 nargs = 0;
 849
 850         sigbuffer_init (&buf, 32);
 851
 852         /* Encode calling convention */
 853         /* Change Any to Standard */
 854         if ((helper->call_conv & 0x03) == 0x03)
 855                 helper->call_conv = 0x01;
 856         /* explicit_this implies has_this */
 857         if (helper->call_conv & 0x40)
 858                 helper->call_conv &= 0x20;
 859
 860         if (helper->call_conv == 0) { /* Unmanaged */
 861                 idx = helper->unmanaged_call_conv - 1;
 862         } else {
 863                 /* Managed */
 864                 idx = helper->call_conv & 0x60; /* has_this + explicit_this */
 865                 if (helper->call_conv & 0x02) /* varargs */
 866                         idx += 0x05;
 867         }
 868
 869         sigbuffer_add_byte (&buf, idx);
 870         sigbuffer_add_value (&buf, nargs);
 871         encode_reflection_type (assembly, helper->return_type, &buf, error);
 872         if (!is_ok (error))
 873                 goto fail;
 874         for (i = 0; i < nargs; ++i) {
 875                 MonoArray *modreqs = NULL;
 876                 MonoArray *modopts = NULL;
 877                 MonoReflectionType *pt;
 878
 879                 if (helper->modreqs && (i < mono_array_length (helper->modreqs)))
 880                         modreqs = mono_array_get (helper->modreqs, MonoArray*, i);
 881                 if (helper->modopts && (i < mono_array_length (helper->modopts)))
 882                         modopts = mono_array_get (helper->modopts, MonoArray*, i);
 883
 884                 encode_custom_modifiers (assembly, modreqs, modopts, &buf, error);
 885                 if (!is_ok (error))
 886                         goto fail;
 887                 pt = mono_array_get (helper->arguments, MonoReflectionType*, i);
 888                 encode_reflection_type (assembly, pt, &buf, error);
 889                 if (!is_ok (error))
 890                         goto fail;
 891         }
 892         idx = sigbuffer_add_to_blob_cached (assembly, &buf);
 893         sigbuffer_free (&buf);
 894
 895         return idx;
 896 fail:
 897         sigbuffer_free (&buf);
 898         return 0;
 899 }
 900 #else /* DISABLE_REFLECTION_EMIT */
 901 guint32
 902 mono_dynimage_encode_reflection_sighelper (MonoDynamicImage *assembly, MonoReflectionSigHelper *helper, MonoError *error)
 903 {
 904         g_assert_not_reached ();
 905         return 0;
 906 }
 907 #endif /* DISABLE_REFLECTION_EMIT */
 908
 909 static MonoArray *
 910 reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig, MonoError *error)
 911 {
 912         MonoReflectionModuleBuilder *module = sig->module;
 913         MonoDynamicImage *assembly = module != NULL ? module->dynamic_image : NULL;
 914         guint32 na = sig->arguments ? mono_array_length (sig->arguments) : 0;
 915         guint32 buflen, i;
 916         MonoArray *result;
 917         SigBuffer buf;
 918
 919         mono_error_init (error);
 920
 921         sigbuffer_init (&buf, 32);
 922
 923         sigbuffer_add_value (&buf, 0x07);
 924         sigbuffer_add_value (&buf, na);
 925         if (assembly != NULL){
 926                 for (i = 0; i < na; ++i) {
 927                         MonoReflectionType *type = mono_array_get (sig->arguments, MonoReflectionType*, i);
 928                         encode_reflection_type (assembly, type, &buf, error);
 929                         if (!is_ok (error)) goto fail;
 930                 }
 931         }
 932
 933         buflen = buf.p - buf.buf;
 934         result = mono_array_new_checked (mono_domain_get (), mono_defaults.byte_class, buflen, error);
 935         if (!is_ok (error)) goto fail;
 936         memcpy (mono_array_addr (result, char, 0), buf.buf, buflen);
 937         sigbuffer_free (&buf);
 938         return result;
 939 fail:
 940         sigbuffer_free (&buf);
 941         return NULL;
 942 }
 943
 944 static MonoArray *
 945 reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig, MonoError *error)
 946 {
 947         MonoDynamicImage *assembly = sig->module->dynamic_image;
 948         guint32 na = sig->arguments ? mono_array_length (sig->arguments) : 0;
 949         guint32 buflen, i;
 950         MonoArray *result;
 951         SigBuffer buf;
 952
 953         mono_error_init (error);
 954
 955         sigbuffer_init (&buf, 32);
 956
 957         sigbuffer_add_value (&buf, 0x06);
 958         for (i = 0; i < na; ++i) {
 959                 MonoReflectionType *type = mono_array_get (sig->arguments, MonoReflectionType*, i);
 960                 encode_reflection_type (assembly, type, &buf, error);
 961                 if (!is_ok (error))
 962                         goto fail;
 963         }
 964
 965         buflen = buf.p - buf.buf;
 966         result = mono_array_new_checked (mono_domain_get (), mono_defaults.byte_class, buflen, error);
 967         if (!is_ok (error)) goto fail;
 968         memcpy (mono_array_addr (result, char, 0), buf.buf, buflen);
 969         sigbuffer_free (&buf);
 970
 971         return result;
 972 fail:
 973         sigbuffer_free (&buf);
 974         return NULL;
 975 }
 976
 977 static char*
 978 type_get_fully_qualified_name (MonoType *type)
 979 {
 980         MONO_REQ_GC_NEUTRAL_MODE;
 981
 982         return mono_type_get_name_full (type, MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED);
 983 }
 984
 985 #ifndef DISABLE_REFLECTION_EMIT_SAVE
 986 guint32
 987 mono_dynimage_save_encode_marshal_blob (MonoDynamicImage *assembly, MonoReflectionMarshal *minfo, MonoError *error)
 988 {
 989         MONO_REQ_GC_UNSAFE_MODE;
 990
 991         mono_error_init (error);
 992
 993         char *str;
 994         SigBuffer buf;
 995         guint32 idx, len;
 996
 997         sigbuffer_init (&buf, 32);
 998
 999         sigbuffer_add_value (&buf, minfo->type);
1000
1001         switch (minfo->type) {
1002         case MONO_NATIVE_BYVALTSTR:
1003         case MONO_NATIVE_BYVALARRAY:
1004                 sigbuffer_add_value (&buf, minfo->count);
1005                 break;
1006         case MONO_NATIVE_LPARRAY:
1007                 if (minfo->eltype || minfo->has_size) {
1008                         sigbuffer_add_value (&buf, minfo->eltype);
1009                         if (minfo->has_size) {
1010                                 sigbuffer_add_value (&buf, minfo->param_num != -1? minfo->param_num: 0);
1011                                 sigbuffer_add_value (&buf, minfo->count != -1? minfo->count: 0);
1012
1013                                 /* LAMESPEC: ElemMult is undocumented */
1014                                 sigbuffer_add_value (&buf, minfo->param_num != -1? 1: 0);
1015                         }
1016                 }
1017                 break;
1018         case MONO_NATIVE_SAFEARRAY:
1019                 if (minfo->eltype)
1020                         sigbuffer_add_value (&buf, minfo->eltype);
1021                 break;
1022         case MONO_NATIVE_CUSTOM:
1023                 if (minfo->guid) {
1024                         str = mono_string_to_utf8_checked (minfo->guid, error);
1025                         if (!is_ok (error)) {
1026                                 sigbuffer_free (&buf);
1027                                 return 0;
1028                         }
1029                         len = strlen (str);
1030                         sigbuffer_add_value (&buf, len);
1031                         sigbuffer_add_mem (&buf, str, len);
1032                         g_free (str);
1033                 } else {
1034                         sigbuffer_add_value (&buf, 0);
1035                 }
1036                 /* native type name */
1037                 sigbuffer_add_value (&buf, 0);
1038                 /* custom marshaler type name */
1039                 if (minfo->marshaltype || minfo->marshaltyperef) {
1040                         if (minfo->marshaltyperef) {
1041                                 MonoType *marshaltype = mono_reflection_type_get_handle ((MonoReflectionType*)minfo->marshaltyperef, error);
1042                                 if (!is_ok (error)) {
1043                                         sigbuffer_free (&buf);
1044                                         return 0;
1045                                 }
1046                                 str = type_get_fully_qualified_name (marshaltype);
1047                         } else {
1048                                 str = mono_string_to_utf8_checked (minfo->marshaltype, error);
1049                                 if (!is_ok (error)) {
1050                                         sigbuffer_free (&buf);
1051                                         return 0;
1052                                 }
1053                         }
1054                         len = strlen (str);
1055                         sigbuffer_add_value (&buf, len);
1056                         sigbuffer_add_mem (&buf, str, len);
1057                         g_free (str);
1058                 } else {
1059                         /* FIXME: Actually a bug, since this field is required.  Punting for now ... */
1060                         sigbuffer_add_value (&buf, 0);
1061                 }
1062                 if (minfo->mcookie) {
1063                         str = mono_string_to_utf8_checked (minfo->mcookie, error);
1064                         if (!is_ok (error)) {
1065                                 sigbuffer_free (&buf);
1066                                 return 0;
1067                         }
1068                         len = strlen (str);
1069                         sigbuffer_add_value (&buf, len);
1070                         sigbuffer_add_mem (&buf, str, len);
1071                         g_free (str);
1072                 } else {
1073                         sigbuffer_add_value (&buf, 0);
1074                 }
1075                 break;
1076         default:
1077                 break;
1078         }
1079         idx = sigbuffer_add_to_blob_cached (assembly, &buf);
1080         sigbuffer_free (&buf);
1081         return idx;
1082 }
1083
1084 guint32
1085 mono_dynimage_save_encode_property_signature (MonoDynamicImage *assembly, MonoReflectionPropertyBuilder *fb, MonoError *error)
1086 {
1087         MONO_REQ_GC_UNSAFE_MODE;
1088
1089         mono_error_init (error);
1090
1091         SigBuffer buf;
1092         guint32 nparams = 0;
1093         MonoReflectionMethodBuilder *mb = fb->get_method;
1094         MonoReflectionMethodBuilder *smb = fb->set_method;
1095         guint32 idx, i;
1096
1097         if (mb && mb->parameters)
1098                 nparams = mono_array_length (mb->parameters);
1099         if (!mb && smb && smb->parameters)
1100                 nparams = mono_array_length (smb->parameters) - 1;
1101         sigbuffer_init (&buf, 32);
1102         if (fb->call_conv & 0x20)
1103                 sigbuffer_add_byte (&buf, 0x28);
1104         else
1105                 sigbuffer_add_byte (&buf, 0x08);
1106         sigbuffer_add_value (&buf, nparams);
1107         if (mb) {
1108                 encode_reflection_type (assembly, (MonoReflectionType*)mb->rtype, &buf, error);
1109                 if (!is_ok (error))
1110                         goto fail;
1111                 for (i = 0; i < nparams; ++i) {
1112                         MonoReflectionType *pt = mono_array_get (mb->parameters, MonoReflectionType*, i);
1113                         encode_reflection_type (assembly, pt, &buf, error);
1114                         if (!is_ok (error))
1115                                 goto fail;
1116                 }
1117         } else if (smb && smb->parameters) {
1118                 /* the property type is the last param */
1119                 encode_reflection_type (assembly, mono_array_get (smb->parameters, MonoReflectionType*, nparams), &buf, error);
1120                 if (!is_ok (error))
1121                         goto fail;
1122
1123                 for (i = 0; i < nparams; ++i) {
1124                         MonoReflectionType *pt = mono_array_get (smb->parameters, MonoReflectionType*, i);
1125                         encode_reflection_type (assembly, pt, &buf, error);
1126                         if (!is_ok (error))
1127                                 goto fail;
1128                 }
1129         } else {
1130                 encode_reflection_type (assembly, (MonoReflectionType*)fb->type, &buf, error);
1131                 if (!is_ok (error))
1132                         goto fail;
1133         }
1134
1135         idx = sigbuffer_add_to_blob_cached (assembly, &buf);
1136         sigbuffer_free (&buf);
1137         return idx;
1138 fail:
1139         sigbuffer_free (&buf);
1140         return 0;
1141 }
1142
1143
1144 #else /*DISABLE_REFLECTION_EMIT_SAVE*/
1145 guint32
1146 mono_dynimage_save_encode_marshal_blob (MonoDynamicImage *assembly, MonoReflectionMarshal *minfo, MonoError *error)
1147 {
1148         g_assert_not_reached ();
1149         return 0;
1150 }
1151
1152 guint32
1153 mono_dynimage_save_encode_property_signature (MonoDynamicImage *assembly, MonoReflectionPropertyBuilder *fb, MonoError *error)
1154 {
1155         g_assert_not_reached ();
1156         return 0;
1157 }
1158 #endif /*DISABLE_REFLECTION_EMIT_SAVE*/
1159
1160 #ifndef DISABLE_REFLECTION_EMIT
1161 MonoArray *
1162 ves_icall_SignatureHelper_get_signature_local (MonoReflectionSigHelper *sig)
1163 {
1164         MonoError error;
1165         MonoArray *result = reflection_sighelper_get_signature_local (sig, &error);
1166         mono_error_set_pending_exception (&error);
1167         return result;
1168 }
1169
1170 MonoArray *
1171 ves_icall_SignatureHelper_get_signature_field (MonoReflectionSigHelper *sig)
1172 {
1173         MonoError error;
1174         MonoArray *result = reflection_sighelper_get_signature_field (sig, &error);
1175         mono_error_set_pending_exception (&error);
1176         return result;
1177 }
1178 #else /* DISABLE_REFLECTION_EMIT */
1179 MonoArray *
1180 ves_icall_SignatureHelper_get_signature_local (MonoReflectionSigHelper *sig)
1181 {
1182         g_assert_not_reached ();
1183         return NULL;
1184 }
1185
1186 MonoArray *
1187 ves_icall_SignatureHelper_get_signature_field (MonoReflectionSigHelper *sig)
1188 {
1189         g_assert_not_reached ();
1190         return NULL;
1191 }
1192
1193 #endif /* DISABLE_REFLECTION_EMIT */