mono/metadata/icall.c

   1 /*
   2  * icall.c:
   3  *
   4  * Authors:
   5  *   Dietmar Maurer (dietmar@ximian.com)
   6  *   Paolo Molaro (lupus@ximian.com)
   7  *       Patrik Torstensson (patrik.torstensson@labs2.com)
   8  *
   9  * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
  10  * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
  11  */
  12
  13 #include <config.h>
  14 #include <glib.h>
  15 #include <stdarg.h>
  16 #include <string.h>
  17 #include <ctype.h>
  18 #ifdef HAVE_ALLOCA_H
  19 #include <alloca.h>
  20 #endif
  21 #ifdef HAVE_SYS_TIME_H
  22 #include <sys/time.h>
  23 #endif
  24 #ifdef HAVE_UNISTD_H
  25 #include <unistd.h>
  26 #endif
  27 #if defined (HOST_WIN32)
  28 #include <stdlib.h>
  29 #endif
  30
  31 #include "mono/utils/mono-membar.h"
  32 #include <mono/metadata/object.h>
  33 #include <mono/metadata/threads.h>
  34 #include <mono/metadata/threads-types.h>
  35 #include <mono/metadata/threadpool.h>
  36 #include <mono/metadata/monitor.h>
  37 #include <mono/metadata/reflection.h>
  38 #include <mono/metadata/assembly.h>
  39 #include <mono/metadata/tabledefs.h>
  40 #include <mono/metadata/exception.h>
  41 #include <mono/metadata/file-io.h>
  42 #include <mono/metadata/console-io.h>
  43 #include <mono/metadata/socket-io.h>
  44 #include <mono/metadata/mono-endian.h>
  45 #include <mono/metadata/tokentype.h>
  46 #include <mono/metadata/domain-internals.h>
  47 #include <mono/metadata/metadata-internals.h>
  48 #include <mono/metadata/class-internals.h>
  49 #include <mono/metadata/marshal.h>
  50 #include <mono/metadata/gc-internal.h>
  51 #include <mono/metadata/mono-gc.h>
  52 #include <mono/metadata/rand.h>
  53 #include <mono/metadata/sysmath.h>
  54 #include <mono/metadata/string-icalls.h>
  55 #include <mono/metadata/debug-helpers.h>
  56 #include <mono/metadata/process.h>
  57 #include <mono/metadata/environment.h>
  58 #include <mono/metadata/profiler-private.h>
  59 #include <mono/metadata/locales.h>
  60 #include <mono/metadata/filewatcher.h>
  61 #include <mono/metadata/char-conversions.h>
  62 #include <mono/metadata/security.h>
  63 #include <mono/metadata/mono-config.h>
  64 #include <mono/metadata/cil-coff.h>
  65 #include <mono/metadata/number-formatter.h>
  66 #include <mono/metadata/security-manager.h>
  67 #include <mono/metadata/security-core-clr.h>
  68 #include <mono/metadata/mono-perfcounters.h>
  69 #include <mono/metadata/mono-debug.h>
  70 #include <mono/io-layer/io-layer.h>
  71 #include <mono/utils/strtod.h>
  72 #include <mono/utils/monobitset.h>
  73 #include <mono/utils/mono-time.h>
  74 #include <mono/utils/mono-proclib.h>
  75 #include <mono/utils/mono-string.h>
  76 #include <mono/utils/mono-error-internals.h>
  77 #include <mono/utils/mono-mmap.h>
  78
  79 #if defined (HOST_WIN32)
  80 #include <windows.h>
  81 #include <shlobj.h>
  82 #endif
  83 #include "decimal.h"
  84
  85 extern MonoString* ves_icall_System_Environment_GetOSVersionString (void) MONO_INTERNAL;
  86
  87 static MonoReflectionAssembly* ves_icall_System_Reflection_Assembly_GetCallingAssembly (void);
  88
  89 static MonoArray*
  90 type_array_from_modifiers (MonoImage *image, MonoType *type, int optional);
  91
  92 /* This is an implementation of a growable pointer array that avoids doing memory allocations for small sizes.
  93  * It works by allocating an initial small array on stack and only going to malloc'd memory if needed.
  94  */
  95 typedef struct {
  96         void **data;
  97         int size;
  98         int capacity;
  99 } MonoPtrArray;
 100
 101 #define MONO_PTR_ARRAY_MAX_ON_STACK (16)
 102
 103 #define mono_ptr_array_init(ARRAY, INITIAL_SIZE) do {\
 104         (ARRAY).size = 0; \
 105         (ARRAY).capacity = MAX (INITIAL_SIZE, MONO_PTR_ARRAY_MAX_ON_STACK); \
 106         (ARRAY).data = INITIAL_SIZE > MONO_PTR_ARRAY_MAX_ON_STACK ? mono_gc_alloc_fixed (sizeof (void*) * INITIAL_SIZE, NULL) : g_newa (void*, MONO_PTR_ARRAY_MAX_ON_STACK); \
 107 } while (0)
 108
 109 #define mono_ptr_array_destroy(ARRAY) do {\
 110         if ((ARRAY).capacity > MONO_PTR_ARRAY_MAX_ON_STACK) \
 111                 mono_gc_free_fixed ((ARRAY).data); \
 112 } while (0)
 113
 114 #define mono_ptr_array_append(ARRAY, VALUE) do { \
 115         if ((ARRAY).size >= (ARRAY).capacity) {\
 116                 void *__tmp = mono_gc_alloc_fixed (sizeof (void*) * (ARRAY).capacity * 2, NULL); \
 117                 memcpy (__tmp, (ARRAY).data, (ARRAY).capacity * sizeof (void*)); \
 118                 if ((ARRAY).capacity > MONO_PTR_ARRAY_MAX_ON_STACK)     \
 119                         mono_gc_free_fixed ((ARRAY).data);      \
 120                 (ARRAY).data = __tmp;                                                                                   \
 121                 (ARRAY).capacity *= 2;\
 122         }\
 123         ((ARRAY).data [(ARRAY).size++] = VALUE); \
 124 } while (0)
 125
 126 #define mono_ptr_array_set(ARRAY, IDX, VALUE) do { \
 127         ((ARRAY).data [(IDX)] = VALUE); \
 128 } while (0)
 129
 130 #define mono_ptr_array_get(ARRAY, IDX) ((ARRAY).data [(IDX)])
 131
 132 #define mono_ptr_array_size(ARRAY) ((ARRAY).size)
 133
 134
 135 static inline MonoBoolean
 136 is_generic_parameter (MonoType *type)
 137 {
 138         return !type->byref && (type->type == MONO_TYPE_VAR || type->type == MONO_TYPE_MVAR);
 139 }
 140
 141 /*
 142  * We expect a pointer to a char, not a string
 143  */
 144 static gboolean
 145 mono_double_ParseImpl (char *ptr, double *result)
 146 {
 147         gchar *endptr = NULL;
 148         *result = 0.0;
 149
 150         MONO_ARCH_SAVE_REGS;
 151
 152 #ifdef __arm__
 153         if (*ptr)
 154                 *result = strtod (ptr, &endptr);
 155 #else
 156         if (*ptr){
 157 #ifdef _EGLIB_MAJOR
 158                 /* Need to lock here because EGLIB (#464316) has locking defined as no-ops, and that breaks mono_strtod */
 159                 EnterCriticalSection (&mono_strtod_mutex);
 160                 *result = mono_strtod (ptr, &endptr);
 161                 LeaveCriticalSection (&mono_strtod_mutex);
 162 #else
 163                 *result = mono_strtod (ptr, &endptr);
 164 #endif
 165         }
 166 #endif
 167
 168         if (!*ptr || (endptr && *endptr))
 169                 return FALSE;
 170
 171         return TRUE;
 172 }
 173
 174 static MonoObject *
 175 ves_icall_System_Array_GetValueImpl (MonoObject *this, guint32 pos)
 176 {
 177         MonoClass *ac;
 178         MonoArray *ao;
 179         gint32 esize;
 180         gpointer *ea;
 181
 182         MONO_ARCH_SAVE_REGS;
 183
 184         ao = (MonoArray *)this;
 185         ac = (MonoClass *)ao->obj.vtable->klass;
 186
 187         esize = mono_array_element_size (ac);
 188         ea = (gpointer*)((char*)ao->vector + (pos * esize));
 189
 190         if (ac->element_class->valuetype)
 191                 return mono_value_box (this->vtable->domain, ac->element_class, ea);
 192         else
 193                 return *ea;
 194 }
 195
 196 static MonoObject *
 197 ves_icall_System_Array_GetValue (MonoObject *this, MonoObject *idxs)
 198 {
 199         MonoClass *ac, *ic;
 200         MonoArray *ao, *io;
 201         gint32 i, pos, *ind;
 202
 203         MONO_ARCH_SAVE_REGS;
 204
 205         MONO_CHECK_ARG_NULL (idxs);
 206
 207         io = (MonoArray *)idxs;
 208         ic = (MonoClass *)io->obj.vtable->klass;
 209
 210         ao = (MonoArray *)this;
 211         ac = (MonoClass *)ao->obj.vtable->klass;
 212
 213         g_assert (ic->rank == 1);
 214         if (io->bounds != NULL || io->max_length !=  ac->rank)
 215                 mono_raise_exception (mono_get_exception_argument (NULL, NULL));
 216
 217         ind = (gint32 *)io->vector;
 218
 219         if (ao->bounds == NULL) {
 220                 if (*ind < 0 || *ind >= ao->max_length)
 221                         mono_raise_exception (mono_get_exception_index_out_of_range ());
 222
 223                 return ves_icall_System_Array_GetValueImpl (this, *ind);
 224         }
 225
 226         for (i = 0; i < ac->rank; i++)
 227                 if ((ind [i] < ao->bounds [i].lower_bound) ||
 228                     (ind [i] >=  (mono_array_lower_bound_t)ao->bounds [i].length + ao->bounds [i].lower_bound))
 229                         mono_raise_exception (mono_get_exception_index_out_of_range ());
 230
 231         pos = ind [0] - ao->bounds [0].lower_bound;
 232         for (i = 1; i < ac->rank; i++)
 233                 pos = pos*ao->bounds [i].length + ind [i] -
 234                         ao->bounds [i].lower_bound;
 235
 236         return ves_icall_System_Array_GetValueImpl (this, pos);
 237 }
 238
 239 static void
 240 ves_icall_System_Array_SetValueImpl (MonoArray *this, MonoObject *value, guint32 pos)
 241 {
 242         MonoClass *ac, *vc, *ec;
 243         gint32 esize, vsize;
 244         gpointer *ea, *va;
 245         int et, vt;
 246
 247         guint64 u64 = 0;
 248         gint64 i64 = 0;
 249         gdouble r64 = 0;
 250
 251         MONO_ARCH_SAVE_REGS;
 252
 253         if (value)
 254                 vc = value->vtable->klass;
 255         else
 256                 vc = NULL;
 257
 258         ac = this->obj.vtable->klass;
 259         ec = ac->element_class;
 260
 261         esize = mono_array_element_size (ac);
 262         ea = (gpointer*)((char*)this->vector + (pos * esize));
 263         va = (gpointer*)((char*)value + sizeof (MonoObject));
 264
 265         if (mono_class_is_nullable (ec)) {
 266                 mono_nullable_init ((guint8*)ea, value, ec);
 267                 return;
 268         }
 269
 270         if (!value) {
 271                 memset (ea, 0,  esize);
 272                 return;
 273         }
 274
 275 #define NO_WIDENING_CONVERSION G_STMT_START{\
 276         mono_raise_exception (mono_get_exception_argument ( \
 277                 "value", "not a widening conversion")); \
 278 }G_STMT_END
 279
 280 #define CHECK_WIDENING_CONVERSION(extra) G_STMT_START{\
 281         if (esize < vsize + (extra)) \
 282                 mono_raise_exception (mono_get_exception_argument ( \
 283                         "value", "not a widening conversion")); \
 284 }G_STMT_END
 285
 286 #define INVALID_CAST G_STMT_START{\
 287         mono_raise_exception (mono_get_exception_invalid_cast ()); \
 288 }G_STMT_END
 289
 290         /* Check element (destination) type. */
 291         switch (ec->byval_arg.type) {
 292         case MONO_TYPE_STRING:
 293                 switch (vc->byval_arg.type) {
 294                 case MONO_TYPE_STRING:
 295                         break;
 296                 default:
 297                         INVALID_CAST;
 298                 }
 299                 break;
 300         case MONO_TYPE_BOOLEAN:
 301                 switch (vc->byval_arg.type) {
 302                 case MONO_TYPE_BOOLEAN:
 303                         break;
 304                 case MONO_TYPE_CHAR:
 305                 case MONO_TYPE_U1:
 306                 case MONO_TYPE_U2:
 307                 case MONO_TYPE_U4:
 308                 case MONO_TYPE_U8:
 309                 case MONO_TYPE_I1:
 310                 case MONO_TYPE_I2:
 311                 case MONO_TYPE_I4:
 312                 case MONO_TYPE_I8:
 313                 case MONO_TYPE_R4:
 314                 case MONO_TYPE_R8:
 315                         NO_WIDENING_CONVERSION;
 316                 default:
 317                         INVALID_CAST;
 318                 }
 319                 break;
 320         }
 321
 322         if (!ec->valuetype) {
 323                 if (!mono_object_isinst (value, ec))
 324                         INVALID_CAST;
 325                 mono_gc_wbarrier_set_arrayref (this, ea, (MonoObject*)value);
 326                 return;
 327         }
 328
 329         if (mono_object_isinst (value, ec)) {
 330                 if (ec->has_references)
 331                         mono_value_copy (ea, (char*)value + sizeof (MonoObject), ec);
 332                 else
 333                         memcpy (ea, (char *)value + sizeof (MonoObject), esize);
 334                 return;
 335         }
 336
 337         if (!vc->valuetype)
 338                 INVALID_CAST;
 339
 340         vsize = mono_class_instance_size (vc) - sizeof (MonoObject);
 341
 342         et = ec->byval_arg.type;
 343         if (et == MONO_TYPE_VALUETYPE && ec->byval_arg.data.klass->enumtype)
 344                 et = mono_class_enum_basetype (ec->byval_arg.data.klass)->type;
 345
 346         vt = vc->byval_arg.type;
 347         if (vt == MONO_TYPE_VALUETYPE && vc->byval_arg.data.klass->enumtype)
 348                 vt = mono_class_enum_basetype (vc->byval_arg.data.klass)->type;
 349
 350 #define ASSIGN_UNSIGNED(etype) G_STMT_START{\
 351         switch (vt) { \
 352         case MONO_TYPE_U1: \
 353         case MONO_TYPE_U2: \
 354         case MONO_TYPE_U4: \
 355         case MONO_TYPE_U8: \
 356         case MONO_TYPE_CHAR: \
 357                 CHECK_WIDENING_CONVERSION(0); \
 358                 *(etype *) ea = (etype) u64; \
 359                 return; \
 360         /* You can't assign a signed value to an unsigned array. */ \
 361         case MONO_TYPE_I1: \
 362         case MONO_TYPE_I2: \
 363         case MONO_TYPE_I4: \
 364         case MONO_TYPE_I8: \
 365         /* You can't assign a floating point number to an integer array. */ \
 366         case MONO_TYPE_R4: \
 367         case MONO_TYPE_R8: \
 368                 NO_WIDENING_CONVERSION; \
 369         } \
 370 }G_STMT_END
 371
 372 #define ASSIGN_SIGNED(etype) G_STMT_START{\
 373         switch (vt) { \
 374         case MONO_TYPE_I1: \
 375         case MONO_TYPE_I2: \
 376         case MONO_TYPE_I4: \
 377         case MONO_TYPE_I8: \
 378                 CHECK_WIDENING_CONVERSION(0); \
 379                 *(etype *) ea = (etype) i64; \
 380                 return; \
 381         /* You can assign an unsigned value to a signed array if the array's */ \
 382         /* element size is larger than the value size. */ \
 383         case MONO_TYPE_U1: \
 384         case MONO_TYPE_U2: \
 385         case MONO_TYPE_U4: \
 386         case MONO_TYPE_U8: \
 387         case MONO_TYPE_CHAR: \
 388                 CHECK_WIDENING_CONVERSION(1); \
 389                 *(etype *) ea = (etype) u64; \
 390                 return; \
 391         /* You can't assign a floating point number to an integer array. */ \
 392         case MONO_TYPE_R4: \
 393         case MONO_TYPE_R8: \
 394                 NO_WIDENING_CONVERSION; \
 395         } \
 396 }G_STMT_END
 397
 398 #define ASSIGN_REAL(etype) G_STMT_START{\
 399         switch (vt) { \
 400         case MONO_TYPE_R4: \
 401         case MONO_TYPE_R8: \
 402                 CHECK_WIDENING_CONVERSION(0); \
 403                 *(etype *) ea = (etype) r64; \
 404                 return; \
 405         /* All integer values fit into a floating point array, so we don't */ \
 406         /* need to CHECK_WIDENING_CONVERSION here. */ \
 407         case MONO_TYPE_I1: \
 408         case MONO_TYPE_I2: \
 409         case MONO_TYPE_I4: \
 410         case MONO_TYPE_I8: \
 411                 *(etype *) ea = (etype) i64; \
 412                 return; \
 413         case MONO_TYPE_U1: \
 414         case MONO_TYPE_U2: \
 415         case MONO_TYPE_U4: \
 416         case MONO_TYPE_U8: \
 417         case MONO_TYPE_CHAR: \
 418                 *(etype *) ea = (etype) u64; \
 419                 return; \
 420         } \
 421 }G_STMT_END
 422
 423         switch (vt) {
 424         case MONO_TYPE_U1:
 425                 u64 = *(guint8 *) va;
 426                 break;
 427         case MONO_TYPE_U2:
 428                 u64 = *(guint16 *) va;
 429                 break;
 430         case MONO_TYPE_U4:
 431                 u64 = *(guint32 *) va;
 432                 break;
 433         case MONO_TYPE_U8:
 434                 u64 = *(guint64 *) va;
 435                 break;
 436         case MONO_TYPE_I1:
 437                 i64 = *(gint8 *) va;
 438                 break;
 439         case MONO_TYPE_I2:
 440                 i64 = *(gint16 *) va;
 441                 break;
 442         case MONO_TYPE_I4:
 443                 i64 = *(gint32 *) va;
 444                 break;
 445         case MONO_TYPE_I8:
 446                 i64 = *(gint64 *) va;
 447                 break;
 448         case MONO_TYPE_R4:
 449                 r64 = *(gfloat *) va;
 450                 break;
 451         case MONO_TYPE_R8:
 452                 r64 = *(gdouble *) va;
 453                 break;
 454         case MONO_TYPE_CHAR:
 455                 u64 = *(guint16 *) va;
 456                 break;
 457         case MONO_TYPE_BOOLEAN:
 458                 /* Boolean is only compatible with itself. */
 459                 switch (et) {
 460                 case MONO_TYPE_CHAR:
 461                 case MONO_TYPE_U1:
 462                 case MONO_TYPE_U2:
 463                 case MONO_TYPE_U4:
 464                 case MONO_TYPE_U8:
 465                 case MONO_TYPE_I1:
 466                 case MONO_TYPE_I2:
 467                 case MONO_TYPE_I4:
 468                 case MONO_TYPE_I8:
 469                 case MONO_TYPE_R4:
 470                 case MONO_TYPE_R8:
 471                         NO_WIDENING_CONVERSION;
 472                 default:
 473                         INVALID_CAST;
 474                 }
 475                 break;
 476         }
 477
 478         /* If we can't do a direct copy, let's try a widening conversion. */
 479         switch (et) {
 480         case MONO_TYPE_CHAR:
 481                 ASSIGN_UNSIGNED (guint16);
 482         case MONO_TYPE_U1:
 483                 ASSIGN_UNSIGNED (guint8);
 484         case MONO_TYPE_U2:
 485                 ASSIGN_UNSIGNED (guint16);
 486         case MONO_TYPE_U4:
 487                 ASSIGN_UNSIGNED (guint32);
 488         case MONO_TYPE_U8:
 489                 ASSIGN_UNSIGNED (guint64);
 490         case MONO_TYPE_I1:
 491                 ASSIGN_SIGNED (gint8);
 492         case MONO_TYPE_I2:
 493                 ASSIGN_SIGNED (gint16);
 494         case MONO_TYPE_I4:
 495                 ASSIGN_SIGNED (gint32);
 496         case MONO_TYPE_I8:
 497                 ASSIGN_SIGNED (gint64);
 498         case MONO_TYPE_R4:
 499                 ASSIGN_REAL (gfloat);
 500         case MONO_TYPE_R8:
 501                 ASSIGN_REAL (gdouble);
 502         }
 503
 504         INVALID_CAST;
 505         /* Not reached, INVALID_CAST does not return. Just to avoid a compiler warning ... */
 506         return;
 507
 508 #undef INVALID_CAST
 509 #undef NO_WIDENING_CONVERSION
 510 #undef CHECK_WIDENING_CONVERSION
 511 #undef ASSIGN_UNSIGNED
 512 #undef ASSIGN_SIGNED
 513 #undef ASSIGN_REAL
 514 }
 515
 516 static void
 517 ves_icall_System_Array_SetValue (MonoArray *this, MonoObject *value,
 518                                  MonoArray *idxs)
 519 {
 520         MonoClass *ac, *ic;
 521         gint32 i, pos, *ind;
 522
 523         MONO_ARCH_SAVE_REGS;
 524
 525         MONO_CHECK_ARG_NULL (idxs);
 526
 527         ic = idxs->obj.vtable->klass;
 528         ac = this->obj.vtable->klass;
 529
 530         g_assert (ic->rank == 1);
 531         if (idxs->bounds != NULL || idxs->max_length != ac->rank)
 532                 mono_raise_exception (mono_get_exception_argument (NULL, NULL));
 533
 534         ind = (gint32 *)idxs->vector;
 535
 536         if (this->bounds == NULL) {
 537                 if (*ind < 0 || *ind >= this->max_length)
 538                         mono_raise_exception (mono_get_exception_index_out_of_range ());
 539
 540                 ves_icall_System_Array_SetValueImpl (this, value, *ind);
 541                 return;
 542         }
 543
 544         for (i = 0; i < ac->rank; i++)
 545                 if ((ind [i] < this->bounds [i].lower_bound) ||
 546                     (ind [i] >= (mono_array_lower_bound_t)this->bounds [i].length + this->bounds [i].lower_bound))
 547                         mono_raise_exception (mono_get_exception_index_out_of_range ());
 548
 549         pos = ind [0] - this->bounds [0].lower_bound;
 550         for (i = 1; i < ac->rank; i++)
 551                 pos = pos * this->bounds [i].length + ind [i] -
 552                         this->bounds [i].lower_bound;
 553
 554         ves_icall_System_Array_SetValueImpl (this, value, pos);
 555 }
 556
 557 static MonoArray *
 558 ves_icall_System_Array_CreateInstanceImpl (MonoReflectionType *type, MonoArray *lengths, MonoArray *bounds)
 559 {
 560         MonoClass *aklass;
 561         MonoArray *array;
 562         uintptr_t *sizes, i;
 563         gboolean bounded = FALSE;
 564
 565         MONO_ARCH_SAVE_REGS;
 566
 567         MONO_CHECK_ARG_NULL (type);
 568         MONO_CHECK_ARG_NULL (lengths);
 569
 570         MONO_CHECK_ARG (lengths, mono_array_length (lengths) > 0);
 571         if (bounds)
 572                 MONO_CHECK_ARG (bounds, mono_array_length (lengths) == mono_array_length (bounds));
 573
 574         for (i = 0; i < mono_array_length (lengths); i++)
 575                 if (mono_array_get (lengths, gint32, i) < 0)
 576                         mono_raise_exception (mono_get_exception_argument_out_of_range (NULL));
 577
 578         if (bounds && (mono_array_length (bounds) == 1) && (mono_array_get (bounds, gint32, 0) != 0))
 579                 /* vectors are not the same as one dimensional arrays with no-zero bounds */
 580                 bounded = TRUE;
 581         else
 582                 bounded = FALSE;
 583
 584         aklass = mono_bounded_array_class_get (mono_class_from_mono_type (type->type), mono_array_length (lengths), bounded);
 585
 586         sizes = alloca (aklass->rank * sizeof(intptr_t) * 2);
 587         for (i = 0; i < aklass->rank; ++i) {
 588                 sizes [i] = mono_array_get (lengths, guint32, i);
 589                 if (bounds)
 590                         sizes [i + aklass->rank] = mono_array_get (bounds, guint32, i);
 591                 else
 592                         sizes [i + aklass->rank] = 0;
 593         }
 594
 595         array = mono_array_new_full (mono_object_domain (type), aklass, sizes, (intptr_t*)sizes + aklass->rank);
 596
 597         return array;
 598 }
 599
 600 static MonoArray *
 601 ves_icall_System_Array_CreateInstanceImpl64 (MonoReflectionType *type, MonoArray *lengths, MonoArray *bounds)
 602 {
 603         MonoClass *aklass;
 604         MonoArray *array;
 605         uintptr_t *sizes, i;
 606         gboolean bounded = FALSE;
 607
 608         MONO_ARCH_SAVE_REGS;
 609
 610         MONO_CHECK_ARG_NULL (type);
 611         MONO_CHECK_ARG_NULL (lengths);
 612
 613         MONO_CHECK_ARG (lengths, mono_array_length (lengths) > 0);
 614         if (bounds)
 615                 MONO_CHECK_ARG (bounds, mono_array_length (lengths) == mono_array_length (bounds));
 616
 617         for (i = 0; i < mono_array_length (lengths); i++)
 618                 if ((mono_array_get (lengths, gint64, i) < 0) ||
 619                     (mono_array_get (lengths, gint64, i) > MONO_ARRAY_MAX_INDEX))
 620                         mono_raise_exception (mono_get_exception_argument_out_of_range (NULL));
 621
 622         if (bounds && (mono_array_length (bounds) == 1) && (mono_array_get (bounds, gint64, 0) != 0))
 623                 /* vectors are not the same as one dimensional arrays with no-zero bounds */
 624                 bounded = TRUE;
 625         else
 626                 bounded = FALSE;
 627
 628         aklass = mono_bounded_array_class_get (mono_class_from_mono_type (type->type), mono_array_length (lengths), bounded);
 629
 630         sizes = alloca (aklass->rank * sizeof(intptr_t) * 2);
 631         for (i = 0; i < aklass->rank; ++i) {
 632                 sizes [i] = mono_array_get (lengths, guint64, i);
 633                 if (bounds)
 634                         sizes [i + aklass->rank] = (mono_array_size_t) mono_array_get (bounds, guint64, i);
 635                 else
 636                         sizes [i + aklass->rank] = 0;
 637         }
 638
 639         array = mono_array_new_full (mono_object_domain (type), aklass, sizes, (intptr_t*)sizes + aklass->rank);
 640
 641         return array;
 642 }
 643
 644 static gint32
 645 ves_icall_System_Array_GetRank (MonoObject *this)
 646 {
 647         MONO_ARCH_SAVE_REGS;
 648
 649         return this->vtable->klass->rank;
 650 }
 651
 652 static gint32
 653 ves_icall_System_Array_GetLength (MonoArray *this, gint32 dimension)
 654 {
 655         gint32 rank = ((MonoObject *)this)->vtable->klass->rank;
 656         uintptr_t length;
 657
 658         MONO_ARCH_SAVE_REGS;
 659
 660         if ((dimension < 0) || (dimension >= rank))
 661                 mono_raise_exception (mono_get_exception_index_out_of_range ());
 662
 663         if (this->bounds == NULL)
 664                 length = this->max_length;
 665         else
 666                 length = this->bounds [dimension].length;
 667
 668 #ifdef MONO_BIG_ARRAYS
 669         if (length > G_MAXINT32)
 670                 mono_raise_exception (mono_get_exception_overflow ());
 671 #endif
 672         return length;
 673 }
 674
 675 static gint64
 676 ves_icall_System_Array_GetLongLength (MonoArray *this, gint32 dimension)
 677 {
 678         gint32 rank = ((MonoObject *)this)->vtable->klass->rank;
 679
 680         MONO_ARCH_SAVE_REGS;
 681
 682         if ((dimension < 0) || (dimension >= rank))
 683                 mono_raise_exception (mono_get_exception_index_out_of_range ());
 684
 685         if (this->bounds == NULL)
 686                 return this->max_length;
 687
 688         return this->bounds [dimension].length;
 689 }
 690
 691 static gint32
 692 ves_icall_System_Array_GetLowerBound (MonoArray *this, gint32 dimension)
 693 {
 694         gint32 rank = ((MonoObject *)this)->vtable->klass->rank;
 695
 696         MONO_ARCH_SAVE_REGS;
 697
 698         if ((dimension < 0) || (dimension >= rank))
 699                 mono_raise_exception (mono_get_exception_index_out_of_range ());
 700
 701         if (this->bounds == NULL)
 702                 return 0;
 703
 704         return this->bounds [dimension].lower_bound;
 705 }
 706
 707 static void
 708 ves_icall_System_Array_ClearInternal (MonoArray *arr, int idx, int length)
 709 {
 710         int sz = mono_array_element_size (mono_object_class (arr));
 711         memset (mono_array_addr_with_size (arr, sz, idx), 0, length * sz);
 712 }
 713
 714 static gboolean
 715 ves_icall_System_Array_FastCopy (MonoArray *source, int source_idx, MonoArray* dest, int dest_idx, int length)
 716 {
 717         int element_size;
 718         void * dest_addr;
 719         void * source_addr;
 720         MonoClass *src_class;
 721         MonoClass *dest_class;
 722         int i;
 723
 724         MONO_ARCH_SAVE_REGS;
 725
 726         if (source->obj.vtable->klass->rank != dest->obj.vtable->klass->rank)
 727                 return FALSE;
 728
 729         if (source->bounds || dest->bounds)
 730                 return FALSE;
 731
 732         /* there's no integer overflow since mono_array_length returns an unsigned integer */
 733         if ((dest_idx + length > mono_array_length (dest)) ||
 734                 (source_idx + length > mono_array_length (source)))
 735                 return FALSE;
 736
 737         src_class = source->obj.vtable->klass->element_class;
 738         dest_class = dest->obj.vtable->klass->element_class;
 739
 740         /*
 741          * Handle common cases.
 742          */
 743
 744         /* Case1: object[] -> valuetype[] (ArrayList::ToArray) */
 745         if (src_class == mono_defaults.object_class && dest_class->valuetype) {
 746                 int has_refs = dest_class->has_references;
 747                 for (i = source_idx; i < source_idx + length; ++i) {
 748                         MonoObject *elem = mono_array_get (source, MonoObject*, i);
 749                         if (elem && !mono_object_isinst (elem, dest_class))
 750                                 return FALSE;
 751                 }
 752
 753                 element_size = mono_array_element_size (dest->obj.vtable->klass);
 754                 memset (mono_array_addr_with_size (dest, element_size, dest_idx), 0, element_size * length);
 755                 for (i = 0; i < length; ++i) {
 756                         MonoObject *elem = mono_array_get (source, MonoObject*, source_idx + i);
 757                         void *addr = mono_array_addr_with_size (dest, element_size, dest_idx + i);
 758                         if (!elem)
 759                                 continue;
 760                         if (has_refs)
 761                                 mono_value_copy (addr, (char *)elem + sizeof (MonoObject), dest_class);
 762                         else
 763                                 memcpy (addr, (char *)elem + sizeof (MonoObject), element_size);
 764                 }
 765                 return TRUE;
 766         }
 767
 768         /* Check if we're copying a char[] <==> (u)short[] */
 769         if (src_class != dest_class) {
 770                 if (dest_class->valuetype || dest_class->enumtype || src_class->valuetype || src_class->enumtype)
 771                         return FALSE;
 772
 773                 if (mono_class_is_subclass_of (src_class, dest_class, FALSE))
 774                         ;
 775                 /* Case2: object[] -> reftype[] (ArrayList::ToArray) */
 776                 else if (mono_class_is_subclass_of (dest_class, src_class, FALSE))
 777                         for (i = source_idx; i < source_idx + length; ++i) {
 778                                 MonoObject *elem = mono_array_get (source, MonoObject*, i);
 779                                 if (elem && !mono_object_isinst (elem, dest_class))
 780                                         return FALSE;
 781                         }
 782                 else
 783                         return FALSE;
 784         }
 785
 786         if (dest_class->valuetype) {
 787                 element_size = mono_array_element_size (source->obj.vtable->klass);
 788                 source_addr = mono_array_addr_with_size (source, element_size, source_idx);
 789                 if (dest_class->has_references) {
 790                         mono_value_copy_array (dest, dest_idx, source_addr, length);
 791                 } else {
 792                         dest_addr = mono_array_addr_with_size (dest, element_size, dest_idx);
 793                         memmove (dest_addr, source_addr, element_size * length);
 794                 }
 795         } else {
 796                 mono_array_memcpy_refs (dest, dest_idx, source, source_idx, length);
 797         }
 798
 799         return TRUE;
 800 }
 801
 802 static void
 803 ves_icall_System_Array_GetGenericValueImpl (MonoObject *this, guint32 pos, gpointer value)
 804 {
 805         MonoClass *ac;
 806         MonoArray *ao;
 807         gint32 esize;
 808         gpointer *ea;
 809
 810         MONO_ARCH_SAVE_REGS;
 811
 812         ao = (MonoArray *)this;
 813         ac = (MonoClass *)ao->obj.vtable->klass;
 814
 815         esize = mono_array_element_size (ac);
 816         ea = (gpointer*)((char*)ao->vector + (pos * esize));
 817
 818         memcpy (value, ea, esize);
 819 }
 820
 821 static void
 822 ves_icall_System_Array_SetGenericValueImpl (MonoObject *this, guint32 pos, gpointer value)
 823 {
 824         MonoClass *ac, *ec;
 825         MonoArray *ao;
 826         gint32 esize;
 827         gpointer *ea;
 828
 829         MONO_ARCH_SAVE_REGS;
 830
 831         ao = (MonoArray *)this;
 832         ac = (MonoClass *)ao->obj.vtable->klass;
 833         ec = ac->element_class;
 834
 835         esize = mono_array_element_size (ac);
 836         ea = (gpointer*)((char*)ao->vector + (pos * esize));
 837
 838         if (MONO_TYPE_IS_REFERENCE (&ec->byval_arg)) {
 839                 g_assert (esize == sizeof (gpointer));
 840                 mono_gc_wbarrier_generic_store (ea, *(gpointer*)value);
 841         } else {
 842                 g_assert (ec->inited);
 843                 g_assert (esize == mono_class_value_size (ec, NULL));
 844                 if (ec->has_references)
 845                         mono_gc_wbarrier_value_copy (ea, value, 1, ec);
 846                 else
 847                         memcpy (ea, value, esize);
 848         }
 849 }
 850
 851 static void
 852 ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray (MonoArray *array, MonoClassField *field_handle)
 853 {
 854         MonoClass *klass = array->obj.vtable->klass;
 855         guint32 size = mono_array_element_size (klass);
 856         MonoType *type = mono_type_get_underlying_type (&klass->element_class->byval_arg);
 857         int align;
 858         const char *field_data;
 859
 860         if (MONO_TYPE_IS_REFERENCE (type) ||
 861                         (type->type == MONO_TYPE_VALUETYPE &&
 862                                 (!mono_type_get_class (type) ||
 863                                 mono_type_get_class (type)->has_references))) {
 864                 MonoException *exc = mono_get_exception_argument("array",
 865                         "Cannot initialize array containing references");
 866                 mono_raise_exception (exc);
 867         }
 868
 869         if (!(field_handle->type->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA)) {
 870                 MonoException *exc = mono_get_exception_argument("field_handle",
 871                         "Field doesn't have an RVA");
 872                 mono_raise_exception (exc);
 873         }
 874
 875         size *= array->max_length;
 876         field_data = mono_field_get_data (field_handle);
 877
 878         if (size > mono_type_size (field_handle->type, &align)) {
 879                 MonoException *exc = mono_get_exception_argument("field_handle",
 880                         "Field not large enough to fill array");
 881                 mono_raise_exception (exc);
 882         }
 883
 884 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
 885 #define SWAP(n) {\
 886         guint ## n *data = (guint ## n *) mono_array_addr (array, char, 0); \
 887         guint ## n *src = (guint ## n *) field_data; \
 888         guint ## n *end = (guint ## n *)((char*)src + size); \
 889 \
 890         for (; src < end; data++, src++) { \
 891                 *data = read ## n (src); \
 892         } \
 893 }
 894
 895         /* printf ("Initialize array with elements of %s type\n", klass->element_class->name); */
 896
 897         switch (type->type) {
 898         case MONO_TYPE_CHAR:
 899         case MONO_TYPE_I2:
 900         case MONO_TYPE_U2:
 901                 SWAP (16);
 902                 break;
 903         case MONO_TYPE_I4:
 904         case MONO_TYPE_U4:
 905         case MONO_TYPE_R4:
 906                 SWAP (32);
 907                 break;
 908         case MONO_TYPE_I8:
 909         case MONO_TYPE_U8:
 910         case MONO_TYPE_R8:
 911                 SWAP (64);
 912                 break;
 913         default:
 914                 memcpy (mono_array_addr (array, char, 0), field_data, size);
 915                 break;
 916         }
 917 #else
 918         memcpy (mono_array_addr (array, char, 0), field_data, size);
 919 #ifdef ARM_FPU_FPA
 920         if (klass->element_class->byval_arg.type == MONO_TYPE_R8) {
 921                 gint i;
 922                 double tmp;
 923                 double *data = (double*)mono_array_addr (array, double, 0);
 924
 925                 for (i = 0; i < size; i++, data++) {
 926                         readr8 (data, &tmp);
 927                         *data = tmp;
 928                 }
 929         }
 930 #endif
 931 #endif
 932 }
 933
 934 static gint
 935 ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetOffsetToStringData (void)
 936 {
 937         MONO_ARCH_SAVE_REGS;
 938
 939         return offsetof (MonoString, chars);
 940 }
 941
 942 static MonoObject *
 943 ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetObjectValue (MonoObject *obj)
 944 {
 945         MONO_ARCH_SAVE_REGS;
 946
 947         if ((obj == NULL) || (! (obj->vtable->klass->valuetype)))
 948                 return obj;
 949         else
 950                 return mono_object_clone (obj);
 951 }
 952
 953 static void
 954 ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunClassConstructor (MonoType *handle)
 955 {
 956         MonoClass *klass;
 957         MonoVTable *vtable;
 958
 959         MONO_CHECK_ARG_NULL (handle);
 960
 961         klass = mono_class_from_mono_type (handle);
 962         MONO_CHECK_ARG (handle, klass);
 963
 964         vtable = mono_class_vtable_full (mono_domain_get (), klass, TRUE);
 965
 966         /* This will call the type constructor */
 967         mono_runtime_class_init (vtable);
 968 }
 969
 970 static void
 971 ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunModuleConstructor (MonoImage *image)
 972 {
 973         MONO_ARCH_SAVE_REGS;
 974
 975         mono_image_check_for_module_cctor (image);
 976         if (image->has_module_cctor) {
 977                 MonoClass *module_klass = mono_class_get (image, MONO_TOKEN_TYPE_DEF | 1);
 978                 /*It's fine to raise the exception here*/
 979                 mono_runtime_class_init (mono_class_vtable_full (mono_domain_get (), module_klass, TRUE));
 980         }
 981 }
 982
 983 static MonoBoolean
 984 ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_SufficientExecutionStack (void)
 985 {
 986         guint8 *stack_addr;
 987         guint8 *current;
 988         size_t stack_size;
 989         /* later make this configurable and per-arch */
 990         int min_size = 4096 * 4 * sizeof (void*);
 991         mono_thread_get_stack_bounds (&stack_addr, &stack_size);
 992         /* if we have no info we are optimistic and assume there is enough room */
 993         if (!stack_addr)
 994                 return TRUE;
 995         current = (guint8 *)&stack_addr;
 996         if (current > stack_addr) {
 997                 if ((current - stack_addr) < min_size)
 998                         return FALSE;
 999         } else {
1000                 if (current - (stack_addr - stack_size) < min_size)
1001                         return FALSE;
1002         }
1003         return TRUE;
1004 }
1005
1006 static MonoObject *
1007 ves_icall_System_Object_MemberwiseClone (MonoObject *this)
1008 {
1009         MONO_ARCH_SAVE_REGS;
1010
1011         return mono_object_clone (this);
1012 }
1013
1014 static gint32
1015 ves_icall_System_ValueType_InternalGetHashCode (MonoObject *this, MonoArray **fields)
1016 {
1017         MonoClass *klass;
1018         MonoObject **values = NULL;
1019         MonoObject *o;
1020         int count = 0;
1021         gint32 result = 0;
1022         MonoClassField* field;
1023         gpointer iter;
1024
1025         MONO_ARCH_SAVE_REGS;
1026
1027         klass = mono_object_class (this);
1028
1029         if (mono_class_num_fields (klass) == 0)
1030                 return mono_object_hash (this);
1031
1032         /*
1033          * Compute the starting value of the hashcode for fields of primitive
1034          * types, and return the remaining fields in an array to the managed side.
1035          * This way, we can avoid costly reflection operations in managed code.
1036          */
1037         iter = NULL;
1038         while ((field = mono_class_get_fields (klass, &iter))) {
1039                 if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
1040                         continue;
1041                 if (mono_field_is_deleted (field))
1042                         continue;
1043                 /* FIXME: Add more types */
1044                 switch (field->type->type) {
1045                 case MONO_TYPE_I4:
1046                         result ^= *(gint32*)((guint8*)this + field->offset);
1047                         break;
1048                 case MONO_TYPE_STRING: {
1049                         MonoString *s;
1050                         s = *(MonoString**)((guint8*)this + field->offset);
1051                         if (s != NULL)
1052                                 result ^= mono_string_hash (s);
1053                         break;
1054                 }
1055                 default:
1056                         if (!values)
1057                                 values = g_newa (MonoObject*, mono_class_num_fields (klass));
1058                         o = mono_field_get_value_object (mono_object_domain (this), field, this);
1059                         values [count++] = o;
1060                 }
1061         }
1062
1063         if (values) {
1064                 int i;
1065                 mono_gc_wbarrier_generic_store (fields, (MonoObject*) mono_array_new (mono_domain_get (), mono_defaults.object_class, count));
1066                 for (i = 0; i < count; ++i)
1067                         mono_array_setref (*fields, i, values [i]);
1068         } else {
1069                 *fields = NULL;
1070         }
1071         return result;
1072 }
1073
1074 static MonoBoolean
1075 ves_icall_System_ValueType_Equals (MonoObject *this, MonoObject *that, MonoArray **fields)
1076 {
1077         MonoClass *klass;
1078         MonoObject **values = NULL;
1079         MonoObject *o;
1080         MonoClassField* field;
1081         gpointer iter;
1082         int count = 0;
1083
1084         MONO_ARCH_SAVE_REGS;
1085
1086         MONO_CHECK_ARG_NULL (that);
1087
1088         if (this->vtable != that->vtable)
1089                 return FALSE;
1090
1091         klass = mono_object_class (this);
1092
1093         if (klass->enumtype && mono_class_enum_basetype (klass) && mono_class_enum_basetype (klass)->type == MONO_TYPE_I4)
1094                 return (*(gint32*)((guint8*)this + sizeof (MonoObject)) == *(gint32*)((guint8*)that + sizeof (MonoObject)));
1095
1096         /*
1097          * Do the comparison for fields of primitive type and return a result if
1098          * possible. Otherwise, return the remaining fields in an array to the
1099          * managed side. This way, we can avoid costly reflection operations in
1100          * managed code.
1101          */
1102         *fields = NULL;
1103         iter = NULL;
1104         while ((field = mono_class_get_fields (klass, &iter))) {
1105                 if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
1106                         continue;
1107                 if (mono_field_is_deleted (field))
1108                         continue;
1109                 /* FIXME: Add more types */
1110                 switch (field->type->type) {
1111                 case MONO_TYPE_U1:
1112                 case MONO_TYPE_I1:
1113                 case MONO_TYPE_BOOLEAN:
1114                         if (*((guint8*)this + field->offset) != *((guint8*)that + field->offset))
1115                                 return FALSE;
1116                         break;
1117                 case MONO_TYPE_U2:
1118                 case MONO_TYPE_I2:
1119                 case MONO_TYPE_CHAR:
1120                         if (*(gint16*)((guint8*)this + field->offset) != *(gint16*)((guint8*)that + field->offset))
1121                                 return FALSE;
1122                         break;
1123                 case MONO_TYPE_U4:
1124                 case MONO_TYPE_I4:
1125                         if (*(gint32*)((guint8*)this + field->offset) != *(gint32*)((guint8*)that + field->offset))
1126                                 return FALSE;
1127                         break;
1128                 case MONO_TYPE_U8:
1129                 case MONO_TYPE_I8:
1130                         if (*(gint64*)((guint8*)this + field->offset) != *(gint64*)((guint8*)that + field->offset))
1131                                 return FALSE;
1132                         break;
1133                 case MONO_TYPE_R4:
1134                         if (*(float*)((guint8*)this + field->offset) != *(float*)((guint8*)that + field->offset))
1135                                 return FALSE;
1136                         break;
1137                 case MONO_TYPE_R8:
1138                         if (*(double*)((guint8*)this + field->offset) != *(double*)((guint8*)that + field->offset))
1139                                 return FALSE;
1140                         break;
1141
1142
1143                 case MONO_TYPE_STRING: {
1144                         MonoString *s1, *s2;
1145                         guint32 s1len, s2len;
1146                         s1 = *(MonoString**)((guint8*)this + field->offset);
1147                         s2 = *(MonoString**)((guint8*)that + field->offset);
1148                         if (s1 == s2)
1149                                 break;
1150                         if ((s1 == NULL) || (s2 == NULL))
1151                                 return FALSE;
1152                         s1len = mono_string_length (s1);
1153                         s2len = mono_string_length (s2);
1154                         if (s1len != s2len)
1155                                 return FALSE;
1156
1157                         if (memcmp (mono_string_chars (s1), mono_string_chars (s2), s1len * sizeof (gunichar2)) != 0)
1158                                 return FALSE;
1159                         break;
1160                 }
1161                 default:
1162                         if (!values)
1163                                 values = g_newa (MonoObject*, mono_class_num_fields (klass) * 2);
1164                         o = mono_field_get_value_object (mono_object_domain (this), field, this);
1165                         values [count++] = o;
1166                         o = mono_field_get_value_object (mono_object_domain (this), field, that);
1167                         values [count++] = o;
1168                 }
1169
1170                 if (klass->enumtype)
1171                         /* enums only have one non-static field */
1172                         break;
1173         }
1174
1175         if (values) {
1176                 int i;
1177                 mono_gc_wbarrier_generic_store (fields, (MonoObject*) mono_array_new (mono_domain_get (), mono_defaults.object_class, count));
1178                 for (i = 0; i < count; ++i)
1179                         mono_array_setref (*fields, i, values [i]);
1180                 return FALSE;
1181         } else {
1182                 return TRUE;
1183         }
1184 }
1185
1186 static MonoReflectionType *
1187 ves_icall_System_Object_GetType (MonoObject *obj)
1188 {
1189         MONO_ARCH_SAVE_REGS;
1190
1191         if (obj->vtable->klass != mono_defaults.transparent_proxy_class)
1192                 return mono_type_get_object (mono_object_domain (obj), &obj->vtable->klass->byval_arg);
1193         else
1194                 return mono_type_get_object (mono_object_domain (obj), &((MonoTransparentProxy*)obj)->remote_class->proxy_class->byval_arg);
1195 }
1196
1197 static void
1198 mono_type_type_from_obj (MonoReflectionType *mtype, MonoObject *obj)
1199 {
1200         MONO_ARCH_SAVE_REGS;
1201
1202         mtype->type = &obj->vtable->klass->byval_arg;
1203         g_assert (mtype->type->type);
1204 }
1205
1206 static gint32
1207 ves_icall_ModuleBuilder_getToken (MonoReflectionModuleBuilder *mb, MonoObject *obj)
1208 {
1209         MONO_ARCH_SAVE_REGS;
1210
1211         MONO_CHECK_ARG_NULL (obj);
1212
1213         return mono_image_create_token (mb->dynamic_image, obj, TRUE, TRUE);
1214 }
1215
1216 static gint32
1217 ves_icall_ModuleBuilder_getMethodToken (MonoReflectionModuleBuilder *mb,
1218                                         MonoReflectionMethod *method,
1219                                         MonoArray *opt_param_types)
1220 {
1221         MONO_ARCH_SAVE_REGS;
1222
1223         MONO_CHECK_ARG_NULL (method);
1224
1225         return mono_image_create_method_token (
1226                 mb->dynamic_image, (MonoObject *) method, opt_param_types);
1227 }
1228
1229 static void
1230 ves_icall_ModuleBuilder_WriteToFile (MonoReflectionModuleBuilder *mb, HANDLE file)
1231 {
1232         MONO_ARCH_SAVE_REGS;
1233
1234         mono_image_create_pefile (mb, file);
1235 }
1236
1237 static void
1238 ves_icall_ModuleBuilder_build_metadata (MonoReflectionModuleBuilder *mb)
1239 {
1240         MONO_ARCH_SAVE_REGS;
1241
1242         mono_image_build_metadata (mb);
1243 }
1244
1245 static void
1246 ves_icall_ModuleBuilder_RegisterToken (MonoReflectionModuleBuilder *mb, MonoObject *obj, guint32 token)
1247 {
1248         MONO_ARCH_SAVE_REGS;
1249
1250         mono_image_register_token (mb->dynamic_image, token, obj);
1251 }
1252
1253 static gboolean
1254 get_caller (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
1255 {
1256         MonoMethod **dest = data;
1257
1258         /* skip unmanaged frames */
1259         if (!managed)
1260                 return FALSE;
1261
1262         if (m == *dest) {
1263                 *dest = NULL;
1264                 return FALSE;
1265         }
1266         if (!(*dest)) {
1267                 *dest = m;
1268                 return TRUE;
1269         }
1270         return FALSE;
1271 }
1272
1273 static gboolean
1274 get_executing (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
1275 {
1276         MonoMethod **dest = data;
1277
1278         /* skip unmanaged frames */
1279         if (!managed)
1280                 return FALSE;
1281
1282         if (!(*dest)) {
1283                 if (!strcmp (m->klass->name_space, "System.Reflection"))
1284                         return FALSE;
1285                 *dest = m;
1286                 return TRUE;
1287         }
1288         return FALSE;
1289 }
1290
1291 static gboolean
1292 get_caller_no_reflection (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
1293 {
1294         MonoMethod **dest = data;
1295
1296         /* skip unmanaged frames */
1297         if (!managed)
1298                 return FALSE;
1299
1300         if (m->wrapper_type != MONO_WRAPPER_NONE)
1301                 return FALSE;
1302
1303         if (m->klass->image == mono_defaults.corlib && !strcmp (m->klass->name_space, "System.Reflection"))
1304                 return FALSE;
1305
1306         if (m == *dest) {
1307                 *dest = NULL;
1308                 return FALSE;
1309         }
1310         if (!(*dest)) {
1311                 *dest = m;
1312                 return TRUE;
1313         }
1314         return FALSE;
1315 }
1316
1317 static MonoReflectionType *
1318 type_from_name (const char *str, MonoBoolean ignoreCase)
1319 {
1320         MonoType *type = NULL;
1321         MonoAssembly *assembly = NULL;
1322         MonoTypeNameParse info;
1323         char *temp_str = g_strdup (str);
1324         gboolean type_resolve = FALSE;
1325
1326         MONO_ARCH_SAVE_REGS;
1327
1328         /* mono_reflection_parse_type() mangles the string */
1329         if (!mono_reflection_parse_type (temp_str, &info)) {
1330                 mono_reflection_free_type_info (&info);
1331                 g_free (temp_str);
1332                 return NULL;
1333         }
1334
1335         if (info.assembly.name) {
1336                 assembly = mono_assembly_load (&info.assembly, NULL, NULL);
1337         } else {
1338                 MonoMethod *m = mono_method_get_last_managed ();
1339                 MonoMethod *dest = m;
1340
1341                 mono_stack_walk_no_il (get_caller_no_reflection, &dest);
1342                 if (!dest)
1343                         dest = m;
1344
1345                 /*
1346                  * FIXME: mono_method_get_last_managed() sometimes returns NULL, thus
1347                  *        causing ves_icall_System_Reflection_Assembly_GetCallingAssembly()
1348                  *        to crash.  This only seems to happen in some strange remoting
1349                  *        scenarios and I was unable to figure out what's happening there.
1350                  *        Dec 10, 2005 - Martin.
1351                  */
1352
1353                 if (dest) {
1354                         assembly = dest->klass->image->assembly;
1355                         type_resolve = TRUE;
1356                 } else {
1357                         g_warning (G_STRLOC);
1358                 }
1359         }
1360
1361         if (assembly) {
1362                 /* When loading from the current assembly, AppDomain.TypeResolve will not be called yet */
1363                 type = mono_reflection_get_type (assembly->image, &info, ignoreCase, &type_resolve);
1364         }
1365
1366         if (!info.assembly.name && !type) /* try mscorlib */
1367                 type = mono_reflection_get_type (NULL, &info, ignoreCase, &type_resolve);
1368
1369         if (assembly && !type && type_resolve) {
1370                 type_resolve = FALSE; /* This will invoke TypeResolve if not done in the first 'if' */
1371                 type = mono_reflection_get_type (assembly->image, &info, ignoreCase, &type_resolve);
1372         }
1373
1374         mono_reflection_free_type_info (&info);
1375         g_free (temp_str);
1376
1377         if (!type)
1378                 return NULL;
1379
1380         return mono_type_get_object (mono_domain_get (), type);
1381 }
1382
1383 #ifdef UNUSED
1384 MonoReflectionType *
1385 mono_type_get (const char *str)
1386 {
1387         char *copy = g_strdup (str);
1388         MonoReflectionType *type = type_from_name (copy, FALSE);
1389
1390         g_free (copy);
1391         return type;
1392 }
1393 #endif
1394
1395 static MonoReflectionType*
1396 ves_icall_type_from_name (MonoString *name,
1397                           MonoBoolean throwOnError,
1398                           MonoBoolean ignoreCase)
1399 {
1400         char *str = mono_string_to_utf8 (name);
1401         MonoReflectionType *type;
1402
1403         type = type_from_name (str, ignoreCase);
1404         g_free (str);
1405         if (type == NULL){
1406                 MonoException *e = NULL;
1407
1408                 if (throwOnError)
1409                         e = mono_get_exception_type_load (name, NULL);
1410
1411                 mono_loader_clear_error ();
1412                 if (e != NULL)
1413                         mono_raise_exception (e);
1414         }
1415
1416         return type;
1417 }
1418
1419
1420 static MonoReflectionType*
1421 ves_icall_type_from_handle (MonoType *handle)
1422 {
1423         MonoDomain *domain = mono_domain_get ();
1424         MonoClass *klass = mono_class_from_mono_type (handle);
1425
1426         MONO_ARCH_SAVE_REGS;
1427
1428         mono_class_init (klass);
1429         return mono_type_get_object (domain, handle);
1430 }
1431
1432 static MonoBoolean
1433 ves_icall_System_Type_EqualsInternal (MonoReflectionType *type, MonoReflectionType *c)
1434 {
1435         MONO_ARCH_SAVE_REGS;
1436
1437         if (c && type->type && c->type)
1438                 return mono_metadata_type_equal (type->type, c->type);
1439         else
1440                 return (type == c) ? TRUE : FALSE;
1441 }
1442
1443 /* System.TypeCode */
1444 typedef enum {
1445         TYPECODE_EMPTY,
1446         TYPECODE_OBJECT,
1447         TYPECODE_DBNULL,
1448         TYPECODE_BOOLEAN,
1449         TYPECODE_CHAR,
1450         TYPECODE_SBYTE,
1451         TYPECODE_BYTE,
1452         TYPECODE_INT16,
1453         TYPECODE_UINT16,
1454         TYPECODE_INT32,
1455         TYPECODE_UINT32,
1456         TYPECODE_INT64,
1457         TYPECODE_UINT64,
1458         TYPECODE_SINGLE,
1459         TYPECODE_DOUBLE,
1460         TYPECODE_DECIMAL,
1461         TYPECODE_DATETIME,
1462         TYPECODE_STRING = 18
1463 } TypeCode;
1464
1465 static guint32
1466 ves_icall_type_GetTypeCodeInternal (MonoReflectionType *type)
1467 {
1468         int t = type->type->type;
1469
1470         MONO_ARCH_SAVE_REGS;
1471
1472         if (type->type->byref)
1473                 return TYPECODE_OBJECT;
1474
1475 handle_enum:
1476         switch (t) {
1477         case MONO_TYPE_VOID:
1478                 return TYPECODE_OBJECT;
1479         case MONO_TYPE_BOOLEAN:
1480                 return TYPECODE_BOOLEAN;
1481         case MONO_TYPE_U1:
1482                 return TYPECODE_BYTE;
1483         case MONO_TYPE_I1:
1484                 return TYPECODE_SBYTE;
1485         case MONO_TYPE_U2:
1486                 return TYPECODE_UINT16;
1487         case MONO_TYPE_I2:
1488                 return TYPECODE_INT16;
1489         case MONO_TYPE_CHAR:
1490                 return TYPECODE_CHAR;
1491         case MONO_TYPE_PTR:
1492         case MONO_TYPE_U:
1493         case MONO_TYPE_I:
1494                 return TYPECODE_OBJECT;
1495         case MONO_TYPE_U4:
1496                 return TYPECODE_UINT32;
1497         case MONO_TYPE_I4:
1498                 return TYPECODE_INT32;
1499         case MONO_TYPE_U8:
1500                 return TYPECODE_UINT64;
1501         case MONO_TYPE_I8:
1502                 return TYPECODE_INT64;
1503         case MONO_TYPE_R4:
1504                 return TYPECODE_SINGLE;
1505         case MONO_TYPE_R8:
1506                 return TYPECODE_DOUBLE;
1507         case MONO_TYPE_VALUETYPE:
1508                 if (type->type->data.klass->enumtype) {
1509                         t = mono_class_enum_basetype (type->type->data.klass)->type;
1510                         goto handle_enum;
1511                 } else {
1512                         MonoClass *k =  type->type->data.klass;
1513                         if (strcmp (k->name_space, "System") == 0) {
1514                                 if (strcmp (k->name, "Decimal") == 0)
1515                                         return TYPECODE_DECIMAL;
1516                                 else if (strcmp (k->name, "DateTime") == 0)
1517                                         return TYPECODE_DATETIME;
1518                         }
1519                 }
1520                 return TYPECODE_OBJECT;
1521         case MONO_TYPE_STRING:
1522                 return TYPECODE_STRING;
1523         case MONO_TYPE_SZARRAY:
1524         case MONO_TYPE_ARRAY:
1525         case MONO_TYPE_OBJECT:
1526         case MONO_TYPE_VAR:
1527         case MONO_TYPE_MVAR:
1528         case MONO_TYPE_TYPEDBYREF:
1529                 return TYPECODE_OBJECT;
1530         case MONO_TYPE_CLASS:
1531                 {
1532                         MonoClass *k =  type->type->data.klass;
1533                         if (strcmp (k->name_space, "System") == 0) {
1534                                 if (strcmp (k->name, "DBNull") == 0)
1535                                         return TYPECODE_DBNULL;
1536                         }
1537                 }
1538                 return TYPECODE_OBJECT;
1539         case MONO_TYPE_GENERICINST:
1540                 return TYPECODE_OBJECT;
1541         default:
1542                 g_error ("type 0x%02x not handled in GetTypeCode()", t);
1543         }
1544         return 0;
1545 }
1546
1547 static guint32
1548 ves_icall_type_is_subtype_of (MonoReflectionType *type, MonoReflectionType *c, MonoBoolean check_interfaces)
1549 {
1550         MonoDomain *domain;
1551         MonoClass *klass;
1552         MonoClass *klassc;
1553
1554         MONO_ARCH_SAVE_REGS;
1555
1556         g_assert (type != NULL);
1557
1558         domain = ((MonoObject *)type)->vtable->domain;
1559
1560         if (!c) /* FIXME: dont know what do do here */
1561                 return 0;
1562
1563         klass = mono_class_from_mono_type (type->type);
1564         klassc = mono_class_from_mono_type (c->type);
1565
1566         if (type->type->byref)
1567                 return klassc == mono_defaults.object_class;
1568
1569         return mono_class_is_subclass_of (klass, klassc, check_interfaces);
1570 }
1571
1572 static guint32
1573 ves_icall_type_is_assignable_from (MonoReflectionType *type, MonoReflectionType *c)
1574 {
1575         MonoDomain *domain;
1576         MonoClass *klass;
1577         MonoClass *klassc;
1578
1579         MONO_ARCH_SAVE_REGS;
1580
1581         g_assert (type != NULL);
1582
1583         domain = ((MonoObject *)type)->vtable->domain;
1584
1585         klass = mono_class_from_mono_type (type->type);
1586         klassc = mono_class_from_mono_type (c->type);
1587
1588         if (type->type->byref && !c->type->byref)
1589                 return FALSE;
1590
1591         return mono_class_is_assignable_from (klass, klassc);
1592 }
1593
1594 static guint32
1595 ves_icall_type_IsInstanceOfType (MonoReflectionType *type, MonoObject *obj)
1596 {
1597         MonoClass *klass = mono_class_from_mono_type (type->type);
1598         return mono_object_isinst (obj, klass) != NULL;
1599 }
1600
1601 static guint32
1602 ves_icall_get_attributes (MonoReflectionType *type)
1603 {
1604         MonoClass *klass = mono_class_from_mono_type (type->type);
1605
1606         MONO_ARCH_SAVE_REGS;
1607
1608         return klass->flags;
1609 }
1610
1611 static MonoReflectionMarshal*
1612 ves_icall_System_Reflection_FieldInfo_GetUnmanagedMarshal (MonoReflectionField *field)
1613 {
1614         MonoClass *klass = field->field->parent;
1615         MonoMarshalType *info;
1616         int i;
1617
1618         if (klass->generic_container ||
1619             (klass->generic_class && klass->generic_class->context.class_inst->is_open))
1620                 return NULL;
1621
1622         info = mono_marshal_load_type_info (klass);
1623
1624         for (i = 0; i < info->num_fields; ++i) {
1625                 if (info->fields [i].field == field->field) {
1626                         if (!info->fields [i].mspec)
1627                                 return NULL;
1628                         else
1629                                 return mono_reflection_marshal_from_marshal_spec (field->object.vtable->domain, klass, info->fields [i].mspec);
1630                 }
1631         }
1632
1633         return NULL;
1634 }
1635
1636 static MonoReflectionField*
1637 ves_icall_System_Reflection_FieldInfo_internal_from_handle_type (MonoClassField *handle, MonoType *type)
1638 {
1639         gboolean found = FALSE;
1640         MonoClass *klass;
1641         MonoClass *k;
1642
1643         g_assert (handle);
1644
1645         if (!type) {
1646                 klass = handle->parent;
1647         } else {
1648                 klass = mono_class_from_mono_type (type);
1649
1650                 /* Check that the field belongs to the class */
1651                 for (k = klass; k; k = k->parent) {
1652                         if (k == handle->parent) {
1653                                 found = TRUE;
1654                                 break;
1655                         }
1656                 }
1657
1658                 if (!found)
1659                         /* The managed code will throw the exception */
1660                         return NULL;
1661         }
1662
1663         return mono_field_get_object (mono_domain_get (), klass, handle);
1664 }
1665
1666 static MonoArray*
1667 ves_icall_System_Reflection_FieldInfo_GetTypeModifiers (MonoReflectionField *field, MonoBoolean optional)
1668 {
1669         MonoType *type = field->field->type;
1670
1671         return type_array_from_modifiers (field->field->parent->image, type, optional);
1672 }
1673
1674 static void
1675 ves_icall_get_method_info (MonoMethod *method, MonoMethodInfo *info)
1676 {
1677         MonoDomain *domain = mono_domain_get ();
1678         MonoMethodSignature* sig;
1679         MONO_ARCH_SAVE_REGS;
1680
1681         sig = mono_method_signature (method);
1682         if (!sig) {
1683                 g_assert (mono_loader_get_last_error ());
1684                 mono_raise_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ()));
1685         }
1686
1687         MONO_STRUCT_SETREF (info, parent, mono_type_get_object (domain, &method->klass->byval_arg));
1688         MONO_STRUCT_SETREF (info, ret, mono_type_get_object (domain, sig->ret));
1689         info->attrs = method->flags;
1690         info->implattrs = method->iflags;
1691         if (sig->call_convention == MONO_CALL_DEFAULT)
1692                 info->callconv = sig->sentinelpos >= 0 ? 2 : 1;
1693         else {
1694                 if (sig->call_convention == MONO_CALL_VARARG || sig->sentinelpos >= 0)
1695                         info->callconv = 2;
1696                 else
1697                         info->callconv = 1;
1698         }
1699         info->callconv |= (sig->hasthis << 5) | (sig->explicit_this << 6);
1700 }
1701
1702 static MonoArray*
1703 ves_icall_get_parameter_info (MonoMethod *method, MonoReflectionMethod *member)
1704 {
1705         MonoDomain *domain = mono_domain_get ();
1706
1707         return mono_param_get_objects_internal (domain, method, member->reftype ? mono_class_from_mono_type (member->reftype->type) : NULL);
1708 }
1709
1710 static MonoReflectionMarshal*
1711 ves_icall_System_MonoMethodInfo_get_retval_marshal (MonoMethod *method)
1712 {
1713         MonoDomain *domain = mono_domain_get ();
1714         MonoReflectionMarshal* res = NULL;
1715         MonoMarshalSpec **mspecs;
1716         int i;
1717
1718         mspecs = g_new (MonoMarshalSpec*, mono_method_signature (method)->param_count + 1);
1719         mono_method_get_marshal_info (method, mspecs);
1720
1721         if (mspecs [0])
1722                 res = mono_reflection_marshal_from_marshal_spec (domain, method->klass, mspecs [0]);
1723
1724         for (i = mono_method_signature (method)->param_count; i >= 0; i--)
1725                 if (mspecs [i])
1726                         mono_metadata_free_marshal_spec (mspecs [i]);
1727         g_free (mspecs);
1728
1729         return res;
1730 }
1731
1732 static gint32
1733 ves_icall_MonoField_GetFieldOffset (MonoReflectionField *field)
1734 {
1735         return field->field->offset - sizeof (MonoObject);
1736 }
1737
1738 static MonoReflectionType*
1739 ves_icall_MonoField_GetParentType (MonoReflectionField *field, MonoBoolean declaring)
1740 {
1741         MonoClass *parent;
1742         MONO_ARCH_SAVE_REGS;
1743
1744         parent = declaring? field->field->parent: field->klass;
1745
1746         return mono_type_get_object (mono_object_domain (field), &parent->byval_arg);
1747 }
1748
1749 static MonoObject *
1750 ves_icall_MonoField_GetValueInternal (MonoReflectionField *field, MonoObject *obj)
1751 {
1752         MonoClass *fklass = field->klass;
1753         MonoClassField *cf = field->field;
1754         MonoDomain *domain = mono_object_domain (field);
1755
1756         if (fklass->image->assembly->ref_only)
1757                 mono_raise_exception (mono_get_exception_invalid_operation (
1758                                         "It is illegal to get the value on a field on a type loaded using the ReflectionOnly methods."));
1759
1760         if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
1761                 mono_security_core_clr_ensure_reflection_access_field (cf);
1762
1763         return mono_field_get_value_object (domain, cf, obj);
1764 }
1765
1766 static void
1767 ves_icall_MonoField_SetValueInternal (MonoReflectionField *field, MonoObject *obj, MonoObject *value)
1768 {
1769         MonoClassField *cf = field->field;
1770         gchar *v;
1771
1772         MONO_ARCH_SAVE_REGS;
1773
1774         if (field->klass->image->assembly->ref_only)
1775                 mono_raise_exception (mono_get_exception_invalid_operation (
1776                                         "It is illegal to set the value on a field on a type loaded using the ReflectionOnly methods."));
1777
1778         if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
1779                 mono_security_core_clr_ensure_reflection_access_field (cf);
1780
1781         v = (gchar *) value;
1782         if (!cf->type->byref) {
1783                 switch (cf->type->type) {
1784                 case MONO_TYPE_U1:
1785                 case MONO_TYPE_I1:
1786                 case MONO_TYPE_BOOLEAN:
1787                 case MONO_TYPE_U2:
1788                 case MONO_TYPE_I2:
1789                 case MONO_TYPE_CHAR:
1790                 case MONO_TYPE_U:
1791                 case MONO_TYPE_I:
1792                 case MONO_TYPE_U4:
1793                 case MONO_TYPE_I4:
1794                 case MONO_TYPE_R4:
1795                 case MONO_TYPE_U8:
1796                 case MONO_TYPE_I8:
1797                 case MONO_TYPE_R8:
1798                 case MONO_TYPE_VALUETYPE:
1799                         if (v != NULL)
1800                                 v += sizeof (MonoObject);
1801                         break;
1802                 case MONO_TYPE_STRING:
1803                 case MONO_TYPE_OBJECT:
1804                 case MONO_TYPE_CLASS:
1805                 case MONO_TYPE_ARRAY:
1806                 case MONO_TYPE_SZARRAY:
1807                         /* Do nothing */
1808                         break;
1809                 case MONO_TYPE_GENERICINST: {
1810                         MonoGenericClass *gclass = cf->type->data.generic_class;
1811                         g_assert (!gclass->context.class_inst->is_open);
1812
1813                         if (mono_class_is_nullable (mono_class_from_mono_type (cf->type))) {
1814                                 MonoClass *nklass = mono_class_from_mono_type (cf->type);
1815                                 MonoObject *nullable;
1816
1817                                 /*
1818                                  * Convert the boxed vtype into a Nullable structure.
1819                                  * This is complicated by the fact that Nullables have
1820                                  * a variable structure.
1821                                  */
1822                                 nullable = mono_object_new (mono_domain_get (), nklass);
1823
1824                                 mono_nullable_init (mono_object_unbox (nullable), value, nklass);
1825
1826                                 v = mono_object_unbox (nullable);
1827                         }
1828                         else
1829                                 if (gclass->container_class->valuetype && (v != NULL))
1830                                         v += sizeof (MonoObject);
1831                         break;
1832                 }
1833                 default:
1834                         g_error ("type 0x%x not handled in "
1835                                  "ves_icall_FieldInfo_SetValueInternal", cf->type->type);
1836                         return;
1837                 }
1838         }
1839
1840         if (cf->type->attrs & FIELD_ATTRIBUTE_STATIC) {
1841                 MonoVTable *vtable = mono_class_vtable_full (mono_object_domain (field), cf->parent, TRUE);
1842                 if (!vtable->initialized)
1843                         mono_runtime_class_init (vtable);
1844                 mono_field_static_set_value (vtable, cf, v);
1845         } else {
1846                 mono_field_set_value (obj, cf, v);
1847         }
1848 }
1849
1850 static MonoObject *
1851 ves_icall_MonoField_GetRawConstantValue (MonoReflectionField *this)
1852 {
1853         MonoObject *o = NULL;
1854         MonoClassField *field = this->field;
1855         MonoClass *klass;
1856         MonoDomain *domain = mono_object_domain (this);
1857         gchar *v;
1858         MonoTypeEnum def_type;
1859         const char *def_value;
1860
1861         MONO_ARCH_SAVE_REGS;
1862
1863         mono_class_init (field->parent);
1864
1865         if (!(field->type->attrs & FIELD_ATTRIBUTE_HAS_DEFAULT))
1866                 mono_raise_exception (mono_get_exception_invalid_operation (NULL));
1867
1868         if (field->parent->image->dynamic) {
1869                 /* FIXME: */
1870                 g_assert_not_reached ();
1871         }
1872
1873         def_value = mono_class_get_field_default_value (field, &def_type);
1874
1875         /*FIXME unify this with reflection.c:mono_get_object_from_blob*/
1876         switch (def_type) {
1877         case MONO_TYPE_U1:
1878         case MONO_TYPE_I1:
1879         case MONO_TYPE_BOOLEAN:
1880         case MONO_TYPE_U2:
1881         case MONO_TYPE_I2:
1882         case MONO_TYPE_CHAR:
1883         case MONO_TYPE_U:
1884         case MONO_TYPE_I:
1885         case MONO_TYPE_U4:
1886         case MONO_TYPE_I4:
1887         case MONO_TYPE_R4:
1888         case MONO_TYPE_U8:
1889         case MONO_TYPE_I8:
1890         case MONO_TYPE_R8: {
1891                 MonoType *t;
1892
1893                 /* boxed value type */
1894                 t = g_new0 (MonoType, 1);
1895                 t->type = def_type;
1896                 klass = mono_class_from_mono_type (t);
1897                 g_free (t);
1898                 o = mono_object_new (domain, klass);
1899                 v = ((gchar *) o) + sizeof (MonoObject);
1900                 mono_get_constant_value_from_blob (domain, def_type, def_value, v);
1901                 break;
1902         }
1903         case MONO_TYPE_STRING:
1904         case MONO_TYPE_CLASS:
1905                 mono_get_constant_value_from_blob (domain, def_type, def_value, &o);
1906                 break;
1907         default:
1908                 g_assert_not_reached ();
1909         }
1910
1911         return o;
1912 }
1913
1914 static MonoReflectionType*
1915 ves_icall_MonoGenericMethod_get_ReflectedType (MonoReflectionGenericMethod *rmethod)
1916 {
1917         MonoMethod *method = rmethod->method.method;
1918
1919         return mono_type_get_object (mono_object_domain (rmethod), &method->klass->byval_arg);
1920 }
1921
1922 /* From MonoProperty.cs */
1923 typedef enum {
1924         PInfo_Attributes = 1,
1925         PInfo_GetMethod  = 1 << 1,
1926         PInfo_SetMethod  = 1 << 2,
1927         PInfo_ReflectedType = 1 << 3,
1928         PInfo_DeclaringType = 1 << 4,
1929         PInfo_Name = 1 << 5
1930 } PInfo;
1931
1932 static void
1933 ves_icall_get_property_info (MonoReflectionProperty *property, MonoPropertyInfo *info, PInfo req_info)
1934 {
1935         MonoDomain *domain = mono_object_domain (property);
1936
1937         MONO_ARCH_SAVE_REGS;
1938
1939         if ((req_info & PInfo_ReflectedType) != 0)
1940                 MONO_STRUCT_SETREF (info, parent, mono_type_get_object (domain, &property->klass->byval_arg));
1941         else if ((req_info & PInfo_DeclaringType) != 0)
1942                 MONO_STRUCT_SETREF (info, parent, mono_type_get_object (domain, &property->property->parent->byval_arg));
1943
1944         if ((req_info & PInfo_Name) != 0)
1945                 MONO_STRUCT_SETREF (info, name, mono_string_new (domain, property->property->name));
1946
1947         if ((req_info & PInfo_Attributes) != 0)
1948                 info->attrs = property->property->attrs;
1949
1950         if ((req_info & PInfo_GetMethod) != 0)
1951                 MONO_STRUCT_SETREF (info, get, property->property->get ?
1952                                                         mono_method_get_object (domain, property->property->get, property->klass): NULL);
1953
1954         if ((req_info & PInfo_SetMethod) != 0)
1955                 MONO_STRUCT_SETREF (info, set, property->property->set ?
1956                                                         mono_method_get_object (domain, property->property->set, property->klass): NULL);
1957         /*
1958          * There may be other methods defined for properties, though, it seems they are not exposed
1959          * in the reflection API
1960          */
1961 }
1962
1963 static void
1964 ves_icall_get_event_info (MonoReflectionMonoEvent *event, MonoEventInfo *info)
1965 {
1966         MonoDomain *domain = mono_object_domain (event);
1967
1968         MONO_ARCH_SAVE_REGS;
1969
1970         MONO_STRUCT_SETREF (info, reflected_type, mono_type_get_object (domain, &event->klass->byval_arg));
1971         MONO_STRUCT_SETREF (info, declaring_type, mono_type_get_object (domain, &event->event->parent->byval_arg));
1972
1973         MONO_STRUCT_SETREF (info, name, mono_string_new (domain, event->event->name));
1974         info->attrs = event->event->attrs;
1975         MONO_STRUCT_SETREF (info, add_method, event->event->add ? mono_method_get_object (domain, event->event->add, NULL): NULL);
1976         MONO_STRUCT_SETREF (info, remove_method, event->event->remove ? mono_method_get_object (domain, event->event->remove, NULL): NULL);
1977         MONO_STRUCT_SETREF (info, raise_method, event->event->raise ? mono_method_get_object (domain, event->event->raise, NULL): NULL);
1978
1979 #ifndef MONO_SMALL_CONFIG
1980         if (event->event->other) {
1981                 int i, n = 0;
1982                 while (event->event->other [n])
1983                         n++;
1984                 MONO_STRUCT_SETREF (info, other_methods, mono_array_new (domain, mono_defaults.method_info_class, n));
1985
1986                 for (i = 0; i < n; i++)
1987                         mono_array_setref (info->other_methods, i, mono_method_get_object (domain, event->event->other [i], NULL));
1988         }
1989 #endif
1990 }
1991
1992 static MonoArray*
1993 ves_icall_Type_GetInterfaces (MonoReflectionType* type)
1994 {
1995         MonoError error;
1996         MonoDomain *domain = mono_object_domain (type);
1997         MonoArray *intf;
1998         GPtrArray *ifaces = NULL;
1999         int i;
2000         MonoClass *class = mono_class_from_mono_type (type->type);
2001         MonoClass *parent;
2002         MonoBitSet *slots;
2003         MonoGenericContext *context = NULL;
2004
2005         MONO_ARCH_SAVE_REGS;
2006
2007         if (class->generic_class && class->generic_class->context.class_inst->is_open) {
2008                 context = mono_class_get_context (class);
2009                 class = class->generic_class->container_class;
2010         }
2011
2012         mono_class_setup_vtable (class);
2013
2014         slots = mono_bitset_new (class->max_interface_id + 1, 0);
2015
2016         for (parent = class; parent; parent = parent->parent) {
2017                 GPtrArray *tmp_ifaces = mono_class_get_implemented_interfaces (parent, &error);
2018                 if (!mono_error_ok (&error)) {
2019                         mono_bitset_free (slots);
2020                         mono_error_raise_exception (&error);
2021                         return NULL;
2022                 } else if (tmp_ifaces) {
2023                         for (i = 0; i < tmp_ifaces->len; ++i) {
2024                                 MonoClass *ic = g_ptr_array_index (tmp_ifaces, i);
2025
2026                                 if (mono_bitset_test (slots, ic->interface_id))
2027                                         continue;
2028
2029                                 mono_bitset_set (slots, ic->interface_id);
2030                                 if (ifaces == NULL)
2031                                         ifaces = g_ptr_array_new ();
2032                                 g_ptr_array_add (ifaces, ic);
2033                         }
2034                         g_ptr_array_free (tmp_ifaces, TRUE);
2035                 }
2036         }
2037         mono_bitset_free (slots);
2038
2039         if (!ifaces)
2040                 return mono_array_new_cached (domain, mono_defaults.monotype_class, 0);
2041
2042         intf = mono_array_new_cached (domain, mono_defaults.monotype_class, ifaces->len);
2043         for (i = 0; i < ifaces->len; ++i) {
2044                 MonoClass *ic = g_ptr_array_index (ifaces, i);
2045                 MonoType *ret = &ic->byval_arg, *inflated = NULL;
2046                 if (context && ic->generic_class && ic->generic_class->context.class_inst->is_open)
2047                         inflated = ret = mono_class_inflate_generic_type (ret, context);
2048
2049                 mono_array_setref (intf, i, mono_type_get_object (domain, ret));
2050                 if (inflated)
2051                         mono_metadata_free_type (inflated);
2052         }
2053         g_ptr_array_free (ifaces, TRUE);
2054
2055         return intf;
2056 }
2057
2058 static void
2059 ves_icall_Type_GetInterfaceMapData (MonoReflectionType *type, MonoReflectionType *iface, MonoArray **targets, MonoArray **methods)
2060 {
2061         gboolean variance_used;
2062         MonoClass *class = mono_class_from_mono_type (type->type);
2063         MonoClass *iclass = mono_class_from_mono_type (iface->type);
2064         MonoReflectionMethod *member;
2065         MonoMethod* method;
2066         gpointer iter;
2067         int i = 0, len, ioffset;
2068         MonoDomain *domain;
2069
2070         MONO_ARCH_SAVE_REGS;
2071
2072         mono_class_setup_vtable (class);
2073
2074         ioffset = mono_class_interface_offset_with_variance (class, iclass, &variance_used);
2075         if (ioffset == -1)
2076                 return;
2077
2078         len = mono_class_num_methods (iclass);
2079         domain = mono_object_domain (type);
2080         mono_gc_wbarrier_generic_store (targets, (MonoObject*) mono_array_new (domain, mono_defaults.method_info_class, len));
2081         mono_gc_wbarrier_generic_store (methods, (MonoObject*) mono_array_new (domain, mono_defaults.method_info_class, len));
2082         iter = NULL;
2083         while ((method = mono_class_get_methods (iclass, &iter))) {
2084                 member = mono_method_get_object (domain, method, iclass);
2085                 mono_array_setref (*methods, i, member);
2086                 member = mono_method_get_object (domain, class->vtable [i + ioffset], class);
2087                 mono_array_setref (*targets, i, member);
2088
2089                 i ++;
2090         }
2091 }
2092
2093 static void
2094 ves_icall_Type_GetPacking (MonoReflectionType *type, guint32 *packing, guint32 *size)
2095 {
2096         MonoClass *klass = mono_class_from_mono_type (type->type);
2097
2098         if (klass->image->dynamic) {
2099                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)type;
2100                 *packing = tb->packing_size;
2101                 *size = tb->class_size;
2102         } else {
2103                 mono_metadata_packing_from_typedef (klass->image, klass->type_token, packing, size);
2104         }
2105 }
2106
2107 static MonoReflectionType*
2108 ves_icall_MonoType_GetElementType (MonoReflectionType *type)
2109 {
2110         MonoClass *class;
2111
2112         MONO_ARCH_SAVE_REGS;
2113
2114         if (!type->type->byref && type->type->type == MONO_TYPE_SZARRAY)
2115                 return mono_type_get_object (mono_object_domain (type), &type->type->data.klass->byval_arg);
2116
2117         class = mono_class_from_mono_type (type->type);
2118
2119         // GetElementType should only return a type for:
2120         // Array Pointer PassedByRef
2121         if (type->type->byref)
2122                 return mono_type_get_object (mono_object_domain (type), &class->byval_arg);
2123         else if (class->element_class && MONO_CLASS_IS_ARRAY (class))
2124                 return mono_type_get_object (mono_object_domain (type), &class->element_class->byval_arg);
2125         else if (class->element_class && type->type->type == MONO_TYPE_PTR)
2126                 return mono_type_get_object (mono_object_domain (type), &class->element_class->byval_arg);
2127         else
2128                 return NULL;
2129 }
2130
2131 static MonoReflectionType*
2132 ves_icall_get_type_parent (MonoReflectionType *type)
2133 {
2134         MonoClass *class = mono_class_from_mono_type (type->type);
2135
2136         MONO_ARCH_SAVE_REGS;
2137
2138         return class->parent ? mono_type_get_object (mono_object_domain (type), &class->parent->byval_arg): NULL;
2139 }
2140
2141 static MonoBoolean
2142 ves_icall_type_ispointer (MonoReflectionType *type)
2143 {
2144         MONO_ARCH_SAVE_REGS;
2145
2146         return type->type->type == MONO_TYPE_PTR;
2147 }
2148
2149 static MonoBoolean
2150 ves_icall_type_isprimitive (MonoReflectionType *type)
2151 {
2152         MONO_ARCH_SAVE_REGS;
2153
2154         return (!type->type->byref && (((type->type->type >= MONO_TYPE_BOOLEAN) && (type->type->type <= MONO_TYPE_R8)) || (type->type->type == MONO_TYPE_I) || (type->type->type == MONO_TYPE_U)));
2155 }
2156
2157 static MonoBoolean
2158 ves_icall_type_isbyref (MonoReflectionType *type)
2159 {
2160         MONO_ARCH_SAVE_REGS;
2161
2162         return type->type->byref;
2163 }
2164
2165 static MonoBoolean
2166 ves_icall_type_iscomobject (MonoReflectionType *type)
2167 {
2168         MonoClass *klass = mono_class_from_mono_type (type->type);
2169         MONO_ARCH_SAVE_REGS;
2170
2171         return (klass && klass->is_com_object);
2172 }
2173
2174 static MonoReflectionModule*
2175 ves_icall_MonoType_get_Module (MonoReflectionType *type)
2176 {
2177         MonoClass *class = mono_class_from_mono_type (type->type);
2178
2179         MONO_ARCH_SAVE_REGS;
2180
2181         return mono_module_get_object (mono_object_domain (type), class->image);
2182 }
2183
2184 static MonoReflectionAssembly*
2185 ves_icall_MonoType_get_Assembly (MonoReflectionType *type)
2186 {
2187         MonoDomain *domain = mono_domain_get ();
2188         MonoClass *class = mono_class_from_mono_type (type->type);
2189
2190         MONO_ARCH_SAVE_REGS;
2191
2192         return mono_assembly_get_object (domain, class->image->assembly);
2193 }
2194
2195 static MonoReflectionType*
2196 ves_icall_MonoType_get_DeclaringType (MonoReflectionType *type)
2197 {
2198         MonoDomain *domain = mono_domain_get ();
2199         MonoClass *class;
2200
2201         MONO_ARCH_SAVE_REGS;
2202
2203         if (type->type->byref)
2204                 return NULL;
2205         if (type->type->type == MONO_TYPE_VAR)
2206                 class = mono_type_get_generic_param_owner (type->type)->owner.klass;
2207         else if (type->type->type == MONO_TYPE_MVAR)
2208                 class = mono_type_get_generic_param_owner (type->type)->owner.method->klass;
2209         else
2210                 class = mono_class_from_mono_type (type->type)->nested_in;
2211
2212         return class ? mono_type_get_object (domain, &class->byval_arg) : NULL;
2213 }
2214
2215 static MonoReflectionType*
2216 ves_icall_MonoType_get_UnderlyingSystemType (MonoReflectionType *type)
2217 {
2218         MonoDomain *domain = mono_domain_get ();
2219         MonoClass *class = mono_class_from_mono_type (type->type);
2220
2221         MONO_ARCH_SAVE_REGS;
2222
2223         if (class->enumtype && mono_class_enum_basetype (class)) /* types that are modified typebuilders may not have enum_basetype set */
2224                 return mono_type_get_object (domain, mono_class_enum_basetype (class));
2225         else if (class->element_class)
2226                 return mono_type_get_object (domain, &class->element_class->byval_arg);
2227         else
2228                 return NULL;
2229 }
2230
2231 static MonoString*
2232 ves_icall_MonoType_get_Name (MonoReflectionType *type)
2233 {
2234         MonoDomain *domain = mono_domain_get ();
2235         MonoClass *class = mono_class_from_mono_type (type->type);
2236
2237         MONO_ARCH_SAVE_REGS;
2238
2239         if (type->type->byref) {
2240                 char *n = g_strdup_printf ("%s&", class->name);
2241                 MonoString *res = mono_string_new (domain, n);
2242
2243                 g_free (n);
2244
2245                 return res;
2246         } else {
2247                 return mono_string_new (domain, class->name);
2248         }
2249 }
2250
2251 static MonoString*
2252 ves_icall_MonoType_get_Namespace (MonoReflectionType *type)
2253 {
2254         MonoDomain *domain = mono_domain_get ();
2255         MonoClass *class = mono_class_from_mono_type (type->type);
2256
2257         MONO_ARCH_SAVE_REGS;
2258
2259         while (class->nested_in)
2260                 class = class->nested_in;
2261
2262         if (class->name_space [0] == '\0')
2263                 return NULL;
2264         else
2265                 return mono_string_new (domain, class->name_space);
2266 }
2267
2268 static gint32
2269 ves_icall_MonoType_GetArrayRank (MonoReflectionType *type)
2270 {
2271         MonoClass *class;
2272
2273         if (type->type->type != MONO_TYPE_ARRAY && type->type->type != MONO_TYPE_SZARRAY)
2274                 mono_raise_exception (mono_get_exception_argument ("type", "Type must be an array type"));
2275
2276         class = mono_class_from_mono_type (type->type);
2277         return class->rank;
2278 }
2279
2280 static MonoArray*
2281 ves_icall_MonoType_GetGenericArguments (MonoReflectionType *type)
2282 {
2283         MonoArray *res;
2284         MonoClass *klass, *pklass;
2285         MonoDomain *domain = mono_object_domain (type);
2286         MonoVTable *array_vtable = mono_class_vtable_full (domain, mono_array_class_get_cached (mono_defaults.systemtype_class, 1), TRUE);
2287         int i;
2288         MONO_ARCH_SAVE_REGS;
2289
2290         klass = mono_class_from_mono_type (type->type);
2291
2292         if (klass->generic_container) {
2293                 MonoGenericContainer *container = klass->generic_container;
2294                 res = mono_array_new_specific (array_vtable, container->type_argc);
2295                 for (i = 0; i < container->type_argc; ++i) {
2296                         pklass = mono_class_from_generic_parameter (mono_generic_container_get_param (container, i), klass->image, FALSE);
2297                         mono_array_setref (res, i, mono_type_get_object (domain, &pklass->byval_arg));
2298                 }
2299         } else if (klass->generic_class) {
2300                 MonoGenericInst *inst = klass->generic_class->context.class_inst;
2301                 res = mono_array_new_specific (array_vtable, inst->type_argc);
2302                 for (i = 0; i < inst->type_argc; ++i)
2303                         mono_array_setref (res, i, mono_type_get_object (domain, inst->type_argv [i]));
2304         } else {
2305                 res = mono_array_new_specific (array_vtable, 0);
2306         }
2307         return res;
2308 }
2309
2310 static gboolean
2311 ves_icall_Type_get_IsGenericTypeDefinition (MonoReflectionType *type)
2312 {
2313         MonoClass *klass;
2314         MONO_ARCH_SAVE_REGS;
2315
2316         if (!IS_MONOTYPE (type))
2317                 return FALSE;
2318
2319         if (type->type->byref)
2320                 return FALSE;
2321
2322         klass = mono_class_from_mono_type (type->type);
2323
2324         return klass->generic_container != NULL;
2325 }
2326
2327 static MonoReflectionType*
2328 ves_icall_Type_GetGenericTypeDefinition_impl (MonoReflectionType *type)
2329 {
2330         MonoClass *klass;
2331         MONO_ARCH_SAVE_REGS;
2332
2333         if (type->type->byref)
2334                 return NULL;
2335
2336         klass = mono_class_from_mono_type (type->type);
2337         if (klass->generic_container) {
2338                 return type; /* check this one */
2339         }
2340         if (klass->generic_class) {
2341                 MonoClass *generic_class = klass->generic_class->container_class;
2342                 gpointer tb;
2343
2344                 tb = mono_class_get_ref_info (generic_class);
2345
2346                 if (generic_class->wastypebuilder && tb)
2347                         return tb;
2348                 else
2349                         return mono_type_get_object (mono_object_domain (type), &generic_class->byval_arg);
2350         }
2351         return NULL;
2352 }
2353
2354 static MonoReflectionType*
2355 ves_icall_Type_MakeGenericType (MonoReflectionType *type, MonoArray *type_array)
2356 {
2357         MonoType *geninst, **types;
2358         int i, count;
2359
2360         MONO_ARCH_SAVE_REGS;
2361
2362         count = mono_array_length (type_array);
2363         types = g_new0 (MonoType *, count);
2364
2365         for (i = 0; i < count; i++) {
2366                 MonoReflectionType *t = mono_array_get (type_array, gpointer, i);
2367                 types [i] = t->type;
2368         }
2369
2370         geninst = mono_reflection_bind_generic_parameters (type, count, types);
2371         g_free (types);
2372         if (!geninst)
2373                 return NULL;
2374
2375         return mono_type_get_object (mono_object_domain (type), geninst);
2376 }
2377
2378 static gboolean
2379 ves_icall_Type_get_IsGenericInstance (MonoReflectionType *type)
2380 {
2381         MonoClass *klass;
2382         MONO_ARCH_SAVE_REGS;
2383
2384         if (type->type->byref)
2385                 return FALSE;
2386
2387         klass = mono_class_from_mono_type (type->type);
2388         return klass->generic_class != NULL;
2389 }
2390
2391 static gboolean
2392 ves_icall_Type_get_IsGenericType (MonoReflectionType *type)
2393 {
2394         MonoClass *klass;
2395         MONO_ARCH_SAVE_REGS;
2396
2397         if (!IS_MONOTYPE (type))
2398                 return FALSE;
2399
2400         if (type->type->byref)
2401                 return FALSE;
2402
2403         klass = mono_class_from_mono_type (type->type);
2404         return klass->generic_class != NULL || klass->generic_container != NULL;
2405 }
2406
2407 static gint32
2408 ves_icall_Type_GetGenericParameterPosition (MonoReflectionType *type)
2409 {
2410         MONO_ARCH_SAVE_REGS;
2411
2412         if (!IS_MONOTYPE (type))
2413                 return -1;
2414
2415         if (is_generic_parameter (type->type))
2416                 return mono_type_get_generic_param_num (type->type);
2417         return -1;
2418 }
2419
2420 static GenericParameterAttributes
2421 ves_icall_Type_GetGenericParameterAttributes (MonoReflectionType *type)
2422 {
2423         MONO_ARCH_SAVE_REGS;
2424
2425         g_assert (IS_MONOTYPE (type));
2426         g_assert (is_generic_parameter (type->type));
2427         return mono_generic_param_info (type->type->data.generic_param)->flags;
2428 }
2429
2430 static MonoArray *
2431 ves_icall_Type_GetGenericParameterConstraints (MonoReflectionType *type)
2432 {
2433         MonoGenericParamInfo *param_info;
2434         MonoDomain *domain;
2435         MonoClass **ptr;
2436         MonoArray *res;
2437         int i, count;
2438
2439         MONO_ARCH_SAVE_REGS;
2440
2441         g_assert (IS_MONOTYPE (type));
2442
2443         domain = mono_object_domain (type);
2444         param_info = mono_generic_param_info (type->type->data.generic_param);
2445         for (count = 0, ptr = param_info->constraints; ptr && *ptr; ptr++, count++)
2446                 ;
2447
2448         res = mono_array_new (domain, mono_defaults.monotype_class, count);
2449         for (i = 0; i < count; i++)
2450                 mono_array_setref (res, i, mono_type_get_object (domain, &param_info->constraints [i]->byval_arg));
2451
2452
2453         return res;
2454 }
2455
2456 static MonoBoolean
2457 ves_icall_MonoType_get_IsGenericParameter (MonoReflectionType *type)
2458 {
2459         MONO_ARCH_SAVE_REGS;
2460         return is_generic_parameter (type->type);
2461 }
2462
2463 static MonoBoolean
2464 ves_icall_TypeBuilder_get_IsGenericParameter (MonoReflectionTypeBuilder *tb)
2465 {
2466         MONO_ARCH_SAVE_REGS;
2467         return is_generic_parameter (tb->type.type);
2468 }
2469
2470 static void
2471 ves_icall_EnumBuilder_setup_enum_type (MonoReflectionType *enumtype,
2472                                                                            MonoReflectionType *t)
2473 {
2474         enumtype->type = t->type;
2475 }
2476
2477 static MonoReflectionMethod*
2478 ves_icall_MonoType_GetCorrespondingInflatedMethod (MonoReflectionType *type,
2479                                                    MonoReflectionMethod* generic)
2480 {
2481         MonoDomain *domain;
2482         MonoClass *klass;
2483         MonoMethod *method;
2484         gpointer iter;
2485
2486         MONO_ARCH_SAVE_REGS;
2487
2488         domain = ((MonoObject *)type)->vtable->domain;
2489
2490         klass = mono_class_from_mono_type (type->type);
2491
2492         iter = NULL;
2493         while ((method = mono_class_get_methods (klass, &iter))) {
2494                 if (method->token == generic->method->token)
2495                         return mono_method_get_object (domain, method, klass);
2496         }
2497
2498         return NULL;
2499 }
2500
2501
2502
2503 static MonoReflectionMethod *
2504 ves_icall_MonoType_get_DeclaringMethod (MonoReflectionType *ref_type)
2505 {
2506         MonoMethod *method;
2507         MonoType *type = ref_type->type;
2508
2509         MONO_ARCH_SAVE_REGS;
2510
2511         if (type->byref || (type->type != MONO_TYPE_MVAR && type->type != MONO_TYPE_VAR))
2512                 mono_raise_exception (mono_get_exception_invalid_operation ("DeclaringMethod can only be used on generic arguments"));
2513         if (type->type == MONO_TYPE_VAR)
2514                 return NULL;
2515
2516         method = mono_type_get_generic_param_owner (type)->owner.method;
2517         g_assert (method);
2518         return mono_method_get_object (mono_object_domain (ref_type), method, method->klass);
2519 }
2520
2521 static MonoReflectionDllImportAttribute*
2522 ves_icall_MonoMethod_GetDllImportAttribute (MonoMethod *method)
2523 {
2524         static MonoClass *DllImportAttributeClass = NULL;
2525         MonoDomain *domain = mono_domain_get ();
2526         MonoReflectionDllImportAttribute *attr;
2527         MonoImage *image = method->klass->image;
2528         MonoMethodPInvoke *piinfo = (MonoMethodPInvoke *)method;
2529         MonoTableInfo *tables = image->tables;
2530         MonoTableInfo *im = &tables [MONO_TABLE_IMPLMAP];
2531         MonoTableInfo *mr = &tables [MONO_TABLE_MODULEREF];
2532         guint32 im_cols [MONO_IMPLMAP_SIZE];
2533         guint32 scope_token;
2534         const char *import = NULL;
2535         const char *scope = NULL;
2536         guint32 flags;
2537
2538         if (!(method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
2539                 return NULL;
2540
2541         if (!DllImportAttributeClass) {
2542                 DllImportAttributeClass =
2543                         mono_class_from_name (mono_defaults.corlib,
2544                                                                   "System.Runtime.InteropServices", "DllImportAttribute");
2545                 g_assert (DllImportAttributeClass);
2546         }
2547
2548         if (method->klass->image->dynamic) {
2549                 MonoReflectionMethodAux *method_aux =
2550                         g_hash_table_lookup (
2551                                                                           ((MonoDynamicImage*)method->klass->image)->method_aux_hash, method);
2552                 if (method_aux) {
2553                         import = method_aux->dllentry;
2554                         scope = method_aux->dll;
2555                 }
2556
2557                 if (!import || !scope) {
2558                         mono_raise_exception (mono_get_exception_argument ("method", "System.Reflection.Emit method with invalid pinvoke information"));
2559                         return NULL;
2560                 }
2561         }
2562         else {
2563                 if (piinfo->implmap_idx) {
2564                         mono_metadata_decode_row (im, piinfo->implmap_idx - 1, im_cols, MONO_IMPLMAP_SIZE);
2565
2566                         piinfo->piflags = im_cols [MONO_IMPLMAP_FLAGS];
2567                         import = mono_metadata_string_heap (image, im_cols [MONO_IMPLMAP_NAME]);
2568                         scope_token = mono_metadata_decode_row_col (mr, im_cols [MONO_IMPLMAP_SCOPE] - 1, MONO_MODULEREF_NAME);
2569                         scope = mono_metadata_string_heap (image, scope_token);
2570                 }
2571         }
2572         flags = piinfo->piflags;
2573
2574         attr = (MonoReflectionDllImportAttribute*)mono_object_new (domain, DllImportAttributeClass);
2575
2576         MONO_OBJECT_SETREF (attr, dll, mono_string_new (domain, scope));
2577         MONO_OBJECT_SETREF (attr, entry_point, mono_string_new (domain, import));
2578         attr->call_conv = (flags & 0x700) >> 8;
2579         attr->charset = ((flags & 0x6) >> 1) + 1;
2580         if (attr->charset == 1)
2581                 attr->charset = 2;
2582         attr->exact_spelling = (flags & 0x1) != 0;
2583         attr->set_last_error = (flags & 0x40) != 0;
2584         attr->best_fit_mapping = (flags & 0x30) == 0x10;
2585         attr->throw_on_unmappable = (flags & 0x3000) == 0x1000;
2586         attr->preserve_sig = FALSE;
2587
2588         return attr;
2589 }
2590
2591 static MonoReflectionMethod *
2592 ves_icall_MonoMethod_GetGenericMethodDefinition (MonoReflectionMethod *method)
2593 {
2594         MonoMethodInflated *imethod;
2595         MonoMethod *result;
2596
2597         MONO_ARCH_SAVE_REGS;
2598
2599         if (method->method->is_generic)
2600                 return method;
2601
2602         if (!method->method->is_inflated)
2603                 return NULL;
2604
2605         imethod = (MonoMethodInflated *) method->method;
2606
2607         result = imethod->declaring;
2608         /* Not a generic method.  */
2609         if (!result->is_generic)
2610                 return NULL;
2611
2612         if (method->method->klass->image->dynamic) {
2613                 MonoDynamicImage *image = (MonoDynamicImage*)method->method->klass->image;
2614                 MonoReflectionMethod *res;
2615
2616                 /*
2617                  * FIXME: Why is this stuff needed at all ? Why can't the code below work for
2618                  * the dynamic case as well ?
2619                  */
2620                 mono_loader_lock ();
2621                 res = mono_g_hash_table_lookup (image->generic_def_objects, imethod);
2622                 mono_loader_unlock ();
2623
2624                 if (res)
2625                         return res;
2626         }
2627
2628         if (imethod->context.class_inst) {
2629                 MonoClass *klass = ((MonoMethod *) imethod)->klass;
2630                 /*Generic methods gets the context of the GTD.*/
2631                 if (mono_class_get_context (klass))
2632                         result = mono_class_inflate_generic_method_full (result, klass, mono_class_get_context (klass));
2633         }
2634
2635         return mono_method_get_object (mono_object_domain (method), result, NULL);
2636 }
2637
2638 static gboolean
2639 ves_icall_MonoMethod_get_IsGenericMethod (MonoReflectionMethod *method)
2640 {
2641         MONO_ARCH_SAVE_REGS;
2642
2643         return mono_method_signature (method->method)->generic_param_count != 0;
2644 }
2645
2646 static gboolean
2647 ves_icall_MonoMethod_get_IsGenericMethodDefinition (MonoReflectionMethod *method)
2648 {
2649         MONO_ARCH_SAVE_REGS;
2650
2651         return method->method->is_generic;
2652 }
2653
2654 static MonoArray*
2655 ves_icall_MonoMethod_GetGenericArguments (MonoReflectionMethod *method)
2656 {
2657         MonoArray *res;
2658         MonoDomain *domain;
2659         int count, i;
2660         MONO_ARCH_SAVE_REGS;
2661
2662         domain = mono_object_domain (method);
2663
2664         if (method->method->is_inflated) {
2665                 MonoGenericInst *inst = mono_method_get_context (method->method)->method_inst;
2666
2667                 if (inst) {
2668                         count = inst->type_argc;
2669                         res = mono_array_new (domain, mono_defaults.systemtype_class, count);
2670
2671                         for (i = 0; i < count; i++)
2672                                 mono_array_setref (res, i, mono_type_get_object (domain, inst->type_argv [i]));
2673
2674                         return res;
2675                 }
2676         }
2677
2678         count = mono_method_signature (method->method)->generic_param_count;
2679         res = mono_array_new (domain, mono_defaults.systemtype_class, count);
2680
2681         for (i = 0; i < count; i++) {
2682                 MonoGenericContainer *container = mono_method_get_generic_container (method->method);
2683                 MonoGenericParam *param = mono_generic_container_get_param (container, i);
2684                 MonoClass *pklass = mono_class_from_generic_parameter (
2685                         param, method->method->klass->image, TRUE);
2686                 mono_array_setref (res, i,
2687                                 mono_type_get_object (domain, &pklass->byval_arg));
2688         }
2689
2690         return res;
2691 }
2692
2693 static MonoObject *
2694 ves_icall_InternalInvoke (MonoReflectionMethod *method, MonoObject *this, MonoArray *params, MonoException **exc)
2695 {
2696         /*
2697          * Invoke from reflection is supposed to always be a virtual call (the API
2698          * is stupid), mono_runtime_invoke_*() calls the provided method, allowing
2699          * greater flexibility.
2700          */
2701         MonoMethod *m = method->method;
2702         int pcount;
2703         void *obj = this;
2704
2705         MONO_ARCH_SAVE_REGS;
2706
2707         *exc = NULL;
2708
2709         if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
2710                 mono_security_core_clr_ensure_reflection_access_method (m);
2711
2712         if (!(m->flags & METHOD_ATTRIBUTE_STATIC)) {
2713                 if (this) {
2714                         if (!mono_object_isinst (this, m->klass)) {
2715                                 mono_gc_wbarrier_generic_store (exc, (MonoObject*) mono_exception_from_name_msg (mono_defaults.corlib, "System.Reflection", "TargetException", "Object does not match target type."));
2716                                 return NULL;
2717                         }
2718                         m = mono_object_get_virtual_method (this, m);
2719                         /* must pass the pointer to the value for valuetype methods */
2720                         if (m->klass->valuetype)
2721                                 obj = mono_object_unbox (this);
2722                 } else if (strcmp (m->name, ".ctor") && !m->wrapper_type) {
2723                         mono_gc_wbarrier_generic_store (exc, (MonoObject*) mono_exception_from_name_msg (mono_defaults.corlib, "System.Reflection", "TargetException", "Non-static method requires a target."));
2724                         return NULL;
2725                 }
2726         }
2727
2728         pcount = params? mono_array_length (params): 0;
2729         if (pcount != mono_method_signature (m)->param_count) {
2730                 mono_gc_wbarrier_generic_store (exc, (MonoObject*) mono_exception_from_name (mono_defaults.corlib, "System.Reflection", "TargetParameterCountException"));
2731                 return NULL;
2732         }
2733
2734         if ((m->klass->flags & TYPE_ATTRIBUTE_ABSTRACT) && !strcmp (m->name, ".ctor") && !this) {
2735                 mono_gc_wbarrier_generic_store (exc, (MonoObject*) mono_exception_from_name_msg (mono_defaults.corlib, "System.Reflection", "TargetException", "Cannot invoke constructor of an abstract class."));
2736                 return NULL;
2737         }
2738
2739         if (m->klass->image->assembly->ref_only) {
2740                 mono_gc_wbarrier_generic_store (exc, (MonoObject*) mono_get_exception_invalid_operation ("It is illegal to invoke a method on a type loaded using the ReflectionOnly api."));
2741                 return NULL;
2742         }
2743
2744         if (m->klass->rank && !strcmp (m->name, ".ctor")) {
2745                 int i;
2746                 uintptr_t *lengths;
2747                 intptr_t *lower_bounds;
2748                 pcount = mono_array_length (params);
2749                 lengths = alloca (sizeof (uintptr_t) * pcount);
2750                 /* Note: the synthetized array .ctors have int32 as argument type */
2751                 for (i = 0; i < pcount; ++i)
2752                         lengths [i] = *(int32_t*) ((char*)mono_array_get (params, gpointer, i) + sizeof (MonoObject));
2753
2754                 if (m->klass->rank == pcount) {
2755                         /* Only lengths provided. */
2756                         lower_bounds = NULL;
2757                 } else {
2758                         g_assert (pcount == (m->klass->rank * 2));
2759                         /* lower bounds are first. */
2760                         lower_bounds = (intptr_t*)lengths;
2761                         lengths += m->klass->rank;
2762                 }
2763
2764                 return (MonoObject*)mono_array_new_full (mono_object_domain (params), m->klass, lengths, lower_bounds);
2765         }
2766         return mono_runtime_invoke_array (m, obj, params, NULL);
2767 }
2768
2769 static MonoObject *
2770 ves_icall_InternalExecute (MonoReflectionMethod *method, MonoObject *this, MonoArray *params, MonoArray **outArgs)
2771 {
2772         MonoDomain *domain = mono_object_domain (method);
2773         MonoMethod *m = method->method;
2774         MonoMethodSignature *sig = mono_method_signature (m);
2775         MonoArray *out_args;
2776         MonoObject *result;
2777         int i, j, outarg_count = 0;
2778
2779         MONO_ARCH_SAVE_REGS;
2780
2781         if (m->klass == mono_defaults.object_class) {
2782
2783                 if (!strcmp (m->name, "FieldGetter")) {
2784                         MonoClass *k = this->vtable->klass;
2785                         MonoString *name;
2786                         char *str;
2787
2788                         /* If this is a proxy, then it must be a CBO */
2789                         if (k == mono_defaults.transparent_proxy_class) {
2790                                 MonoTransparentProxy *tp = (MonoTransparentProxy*) this;
2791                                 this = tp->rp->unwrapped_server;
2792                                 g_assert (this);
2793                                 k = this->vtable->klass;
2794                         }
2795
2796                         name = mono_array_get (params, MonoString *, 1);
2797                         str = mono_string_to_utf8 (name);
2798
2799                         do {
2800                                 MonoClassField* field = mono_class_get_field_from_name (k, str);
2801                                 if (field) {
2802                                         MonoClass *field_klass =  mono_class_from_mono_type (field->type);
2803                                         if (field_klass->valuetype)
2804                                                 result = mono_value_box (domain, field_klass, (char *)this + field->offset);
2805                                         else
2806                                                 result = *((gpointer *)((char *)this + field->offset));
2807
2808                                         out_args = mono_array_new (domain, mono_defaults.object_class, 1);
2809                                         mono_gc_wbarrier_generic_store (outArgs, (MonoObject*) out_args);
2810                                         mono_array_setref (out_args, 0, result);
2811                                         g_free (str);
2812                                         return NULL;
2813                                 }
2814                                 k = k->parent;
2815                         } while (k);
2816
2817                         g_free (str);
2818                         g_assert_not_reached ();
2819
2820                 } else if (!strcmp (m->name, "FieldSetter")) {
2821                         MonoClass *k = this->vtable->klass;
2822                         MonoString *name;
2823                         guint32 size;
2824                         gint32 align;
2825                         char *str;
2826
2827                         /* If this is a proxy, then it must be a CBO */
2828                         if (k == mono_defaults.transparent_proxy_class) {
2829                                 MonoTransparentProxy *tp = (MonoTransparentProxy*) this;
2830                                 this = tp->rp->unwrapped_server;
2831                                 g_assert (this);
2832                                 k = this->vtable->klass;
2833                         }
2834
2835                         name = mono_array_get (params, MonoString *, 1);
2836                         str = mono_string_to_utf8 (name);
2837
2838                         do {
2839                                 MonoClassField* field = mono_class_get_field_from_name (k, str);
2840                                 if (field) {
2841                                         MonoClass *field_klass =  mono_class_from_mono_type (field->type);
2842                                         MonoObject *val = mono_array_get (params, gpointer, 2);
2843
2844                                         if (field_klass->valuetype) {
2845                                                 size = mono_type_size (field->type, &align);
2846                                                 g_assert (size == mono_class_value_size (field_klass, NULL));
2847                                                 mono_gc_wbarrier_value_copy ((char *)this + field->offset, (char*)val + sizeof (MonoObject), 1, field_klass);
2848                                         } else {
2849                                                 mono_gc_wbarrier_set_field (this, (char*)this + field->offset, val);
2850                                         }
2851
2852                                         out_args = mono_array_new (domain, mono_defaults.object_class, 0);
2853                                         mono_gc_wbarrier_generic_store (outArgs, (MonoObject*) out_args);
2854
2855                                         g_free (str);
2856                                         return NULL;
2857                                 }
2858
2859                                 k = k->parent;
2860                         } while (k);
2861
2862                         g_free (str);
2863                         g_assert_not_reached ();
2864
2865                 }
2866         }
2867
2868         for (i = 0; i < mono_array_length (params); i++) {
2869                 if (sig->params [i]->byref)
2870                         outarg_count++;
2871         }
2872
2873         out_args = mono_array_new (domain, mono_defaults.object_class, outarg_count);
2874
2875         /* handle constructors only for objects already allocated */
2876         if (!strcmp (method->method->name, ".ctor"))
2877                 g_assert (this);
2878
2879         /* This can be called only on MBR objects, so no need to unbox for valuetypes. */
2880         g_assert (!method->method->klass->valuetype);
2881         result = mono_runtime_invoke_array (method->method, this, params, NULL);
2882
2883         for (i = 0, j = 0; i < mono_array_length (params); i++) {
2884                 if (sig->params [i]->byref) {
2885                         gpointer arg;
2886                         arg = mono_array_get (params, gpointer, i);
2887                         mono_array_setref (out_args, j, arg);
2888                         j++;
2889                 }
2890         }
2891
2892         mono_gc_wbarrier_generic_store (outArgs, (MonoObject*) out_args);
2893
2894         return result;
2895 }
2896
2897 static guint64
2898 read_enum_value (char *mem, int type)
2899 {
2900         switch (type) {
2901         case MONO_TYPE_U1:
2902                 return *(guint8*)mem;
2903         case MONO_TYPE_I1:
2904                 return *(gint8*)mem;
2905         case MONO_TYPE_U2:
2906                 return *(guint16*)mem;
2907         case MONO_TYPE_I2:
2908                 return *(gint16*)mem;
2909         case MONO_TYPE_U4:
2910                 return *(guint32*)mem;
2911         case MONO_TYPE_I4:
2912                 return *(gint32*)mem;
2913         case MONO_TYPE_U8:
2914                 return *(guint64*)mem;
2915         case MONO_TYPE_I8:
2916                 return *(gint64*)mem;
2917         default:
2918                 g_assert_not_reached ();
2919         }
2920         return 0;
2921 }
2922
2923 static void
2924 write_enum_value (char *mem, int type, guint64 value)
2925 {
2926         switch (type) {
2927         case MONO_TYPE_U1:
2928         case MONO_TYPE_I1: {
2929                 guint8 *p = (guint8*)mem;
2930                 *p = value;
2931                 break;
2932         }
2933         case MONO_TYPE_U2:
2934         case MONO_TYPE_I2: {
2935                 guint16 *p = (void*)mem;
2936                 *p = value;
2937                 break;
2938         }
2939         case MONO_TYPE_U4:
2940         case MONO_TYPE_I4: {
2941                 guint32 *p = (void*)mem;
2942                 *p = value;
2943                 break;
2944         }
2945         case MONO_TYPE_U8:
2946         case MONO_TYPE_I8: {
2947                 guint64 *p = (void*)mem;
2948                 *p = value;
2949                 break;
2950         }
2951         default:
2952                 g_assert_not_reached ();
2953         }
2954         return;
2955 }
2956
2957 static MonoObject *
2958 ves_icall_System_Enum_ToObject (MonoReflectionType *enumType, MonoObject *value)
2959 {
2960         MonoDomain *domain;
2961         MonoClass *enumc, *objc;
2962         MonoObject *res;
2963         MonoType *etype;
2964         guint64 val;
2965
2966         MONO_ARCH_SAVE_REGS;
2967
2968         MONO_CHECK_ARG_NULL (enumType);
2969         MONO_CHECK_ARG_NULL (value);
2970
2971         domain = mono_object_domain (enumType);
2972         enumc = mono_class_from_mono_type (enumType->type);
2973         objc = value->vtable->klass;
2974
2975         if (!enumc->enumtype)
2976                 mono_raise_exception (mono_get_exception_argument ("enumType", "Type provided must be an Enum."));
2977         if (!((objc->enumtype) || (objc->byval_arg.type >= MONO_TYPE_I1 && objc->byval_arg.type <= MONO_TYPE_U8)))
2978                 mono_raise_exception (mono_get_exception_argument ("value", "The value passed in must be an enum base or an underlying type for an enum, such as an Int32."));
2979
2980         etype = mono_class_enum_basetype (enumc);
2981         if (!etype)
2982                 /* MS throws this for typebuilders */
2983                 mono_raise_exception (mono_get_exception_argument ("Type must be a type provided by the runtime.", "enumType"));
2984
2985         res = mono_object_new (domain, enumc);
2986         val = read_enum_value ((char *)value + sizeof (MonoObject), objc->enumtype? mono_class_enum_basetype (objc)->type: objc->byval_arg.type);
2987         write_enum_value ((char *)res + sizeof (MonoObject), etype->type, val);
2988
2989         return res;
2990 }
2991
2992 static MonoObject *
2993 ves_icall_System_Enum_get_value (MonoObject *this)
2994 {
2995         MonoObject *res;
2996         MonoClass *enumc;
2997         gpointer dst;
2998         gpointer src;
2999         int size;
3000
3001         MONO_ARCH_SAVE_REGS;
3002
3003         if (!this)
3004                 return NULL;
3005
3006         g_assert (this->vtable->klass->enumtype);
3007
3008         enumc = mono_class_from_mono_type (mono_class_enum_basetype (this->vtable->klass));
3009         res = mono_object_new (mono_object_domain (this), enumc);
3010         dst = (char *)res + sizeof (MonoObject);
3011         src = (char *)this + sizeof (MonoObject);
3012         size = mono_class_value_size (enumc, NULL);
3013
3014         memcpy (dst, src, size);
3015
3016         return res;
3017 }
3018
3019 static MonoReflectionType *
3020 ves_icall_System_Enum_get_underlying_type (MonoReflectionType *type)
3021 {
3022         MonoType *etype;
3023
3024         MONO_ARCH_SAVE_REGS;
3025
3026         etype = mono_class_enum_basetype (mono_class_from_mono_type (type->type));
3027         if (!etype)
3028                 /* MS throws this for typebuilders */
3029                 mono_raise_exception (mono_get_exception_argument ("Type must be a type provided by the runtime.", "enumType"));
3030
3031         return mono_type_get_object (mono_object_domain (type), etype);
3032 }
3033
3034 static int
3035 ves_icall_System_Enum_compare_value_to (MonoObject *this, MonoObject *other)
3036 {
3037         gpointer tdata = (char *)this + sizeof (MonoObject);
3038         gpointer odata = (char *)other + sizeof (MonoObject);
3039         MonoType *basetype = mono_class_enum_basetype (this->vtable->klass);
3040         g_assert (basetype);
3041
3042 #define COMPARE_ENUM_VALUES(ENUM_TYPE) do { \
3043                 ENUM_TYPE me = *((ENUM_TYPE*)tdata); \
3044                 ENUM_TYPE other = *((ENUM_TYPE*)odata); \
3045                 if (me == other) \
3046                         return 0; \
3047                 return me > other ? 1 : -1; \
3048         } while (0)
3049
3050 #define COMPARE_ENUM_VALUES_RANGE(ENUM_TYPE) do { \
3051                 ENUM_TYPE me = *((ENUM_TYPE*)tdata); \
3052                 ENUM_TYPE other = *((ENUM_TYPE*)odata); \
3053                 if (me == other) \
3054                         return 0; \
3055                 return me - other; \
3056         } while (0)
3057
3058         switch (basetype->type) {
3059                 case MONO_TYPE_U1:
3060                         COMPARE_ENUM_VALUES (guint8);
3061                 case MONO_TYPE_I1:
3062                         COMPARE_ENUM_VALUES (gint8);
3063                 case MONO_TYPE_CHAR:
3064                 case MONO_TYPE_U2:
3065                         COMPARE_ENUM_VALUES_RANGE (guint16);
3066                 case MONO_TYPE_I2:
3067                         COMPARE_ENUM_VALUES (gint16);
3068                 case MONO_TYPE_U4:
3069                         COMPARE_ENUM_VALUES (guint32);
3070                 case MONO_TYPE_I4:
3071                         COMPARE_ENUM_VALUES (gint32);
3072                 case MONO_TYPE_U8:
3073                         COMPARE_ENUM_VALUES (guint64);
3074                 case MONO_TYPE_I8:
3075                         COMPARE_ENUM_VALUES (gint64);
3076                 default:
3077                         g_error ("Implement type 0x%02x in get_hashcode", basetype->type);
3078         }
3079 #undef COMPARE_ENUM_VALUES_RANGE
3080 #undef COMPARE_ENUM_VALUES
3081         return 0;
3082 }
3083
3084 static int
3085 ves_icall_System_Enum_get_hashcode (MonoObject *this)
3086 {
3087         gpointer data = (char *)this + sizeof (MonoObject);
3088         MonoType *basetype = mono_class_enum_basetype (this->vtable->klass);
3089         g_assert (basetype);
3090
3091         switch (basetype->type) {
3092                 case MONO_TYPE_I1:
3093                         return *((gint8*)data);
3094                 case MONO_TYPE_U1:
3095                         return *((guint8*)data);
3096                 case MONO_TYPE_CHAR:
3097                 case MONO_TYPE_U2:
3098                         return *((guint16*)data);
3099
3100                 case MONO_TYPE_I2:
3101                         return *((gint16*)data);
3102                 case MONO_TYPE_U4:
3103                         return *((guint32*)data);
3104                 case MONO_TYPE_I4:
3105                         return *((gint32*)data);
3106                 case MONO_TYPE_U8:
3107                 case MONO_TYPE_I8: {
3108                         gint64 value = *((gint64*)data);
3109                         return (gint)(value & 0xffffffff) ^ (int)(value >> 32);
3110                 }
3111                 default:
3112                         g_error ("Implement type 0x%02x in get_hashcode", basetype->type);
3113         }
3114         return 0;
3115 }
3116
3117 static void
3118 ves_icall_get_enum_info (MonoReflectionType *type, MonoEnumInfo *info)
3119 {
3120         MonoDomain *domain = mono_object_domain (type);
3121         MonoClass *enumc = mono_class_from_mono_type (type->type);
3122         guint j = 0, nvalues, crow;
3123         gpointer iter;
3124         MonoClassField *field;
3125
3126         MONO_ARCH_SAVE_REGS;
3127
3128         MONO_STRUCT_SETREF (info, utype, mono_type_get_object (domain, mono_class_enum_basetype (enumc)));
3129         nvalues = mono_class_num_fields (enumc) ? mono_class_num_fields (enumc) - 1 : 0;
3130         MONO_STRUCT_SETREF (info, names, mono_array_new (domain, mono_defaults.string_class, nvalues));
3131         MONO_STRUCT_SETREF (info, values, mono_array_new (domain, enumc, nvalues));
3132
3133         crow = -1;
3134         iter = NULL;
3135         while ((field = mono_class_get_fields (enumc, &iter))) {
3136                 const char *p;
3137                 int len;
3138                 MonoTypeEnum def_type;
3139
3140                 if (strcmp ("value__", mono_field_get_name (field)) == 0)
3141                         continue;
3142                 if (mono_field_is_deleted (field))
3143                         continue;
3144                 mono_array_setref (info->names, j, mono_string_new (domain, mono_field_get_name (field)));
3145
3146                 p = mono_class_get_field_default_value (field, &def_type);
3147                 len = mono_metadata_decode_blob_size (p, &p);
3148                 switch (mono_class_enum_basetype (enumc)->type) {
3149                 case MONO_TYPE_U1:
3150                 case MONO_TYPE_I1:
3151                         mono_array_set (info->values, gchar, j, *p);
3152                         break;
3153                 case MONO_TYPE_CHAR:
3154                 case MONO_TYPE_U2:
3155                 case MONO_TYPE_I2:
3156                         mono_array_set (info->values, gint16, j, read16 (p));
3157                         break;
3158                 case MONO_TYPE_U4:
3159                 case MONO_TYPE_I4:
3160                         mono_array_set (info->values, gint32, j, read32 (p));
3161                         break;
3162                 case MONO_TYPE_U8:
3163                 case MONO_TYPE_I8:
3164                         mono_array_set (info->values, gint64, j, read64 (p));
3165                         break;
3166                 default:
3167                         g_error ("Implement type 0x%02x in get_enum_info", mono_class_enum_basetype (enumc)->type);
3168                 }
3169                 ++j;
3170         }
3171 }
3172
3173 enum {
3174         BFLAGS_IgnoreCase = 1,
3175         BFLAGS_DeclaredOnly = 2,
3176         BFLAGS_Instance = 4,
3177         BFLAGS_Static = 8,
3178         BFLAGS_Public = 0x10,
3179         BFLAGS_NonPublic = 0x20,
3180         BFLAGS_FlattenHierarchy = 0x40,
3181         BFLAGS_InvokeMethod = 0x100,
3182         BFLAGS_CreateInstance = 0x200,
3183         BFLAGS_GetField = 0x400,
3184         BFLAGS_SetField = 0x800,
3185         BFLAGS_GetProperty = 0x1000,
3186         BFLAGS_SetProperty = 0x2000,
3187         BFLAGS_ExactBinding = 0x10000,
3188         BFLAGS_SuppressChangeType = 0x20000,
3189         BFLAGS_OptionalParamBinding = 0x40000
3190 };
3191
3192 static MonoReflectionField *
3193 ves_icall_Type_GetField (MonoReflectionType *type, MonoString *name, guint32 bflags)
3194 {
3195         MonoDomain *domain;
3196         MonoClass *startklass, *klass;
3197         int match;
3198         MonoClassField *field;
3199         gpointer iter;
3200         char *utf8_name;
3201         int (*compare_func) (const char *s1, const char *s2) = NULL;
3202         domain = ((MonoObject *)type)->vtable->domain;
3203         klass = startklass = mono_class_from_mono_type (type->type);
3204
3205         MONO_ARCH_SAVE_REGS;
3206
3207         if (!name)
3208                 mono_raise_exception (mono_get_exception_argument_null ("name"));
3209         if (type->type->byref)
3210                 return NULL;
3211
3212         compare_func = (bflags & BFLAGS_IgnoreCase) ? mono_utf8_strcasecmp : strcmp;
3213
3214 handle_parent:
3215         if (klass->exception_type != MONO_EXCEPTION_NONE)
3216                 mono_raise_exception (mono_class_get_exception_for_failure (klass));
3217
3218         iter = NULL;
3219         while ((field = mono_class_get_fields (klass, &iter))) {
3220                 match = 0;
3221
3222                 if (field->type == NULL)
3223                         continue;
3224                 if (mono_field_is_deleted (field))
3225                         continue;
3226                 if ((field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK) == FIELD_ATTRIBUTE_PUBLIC) {
3227                         if (bflags & BFLAGS_Public)
3228                                 match++;
3229                 } else if ((klass == startklass) || (field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK) != FIELD_ATTRIBUTE_PRIVATE) {
3230                         if (bflags & BFLAGS_NonPublic) {
3231                                 match++;
3232                         }
3233                 }
3234                 if (!match)
3235                         continue;
3236                 match = 0;
3237                 if (field->type->attrs & FIELD_ATTRIBUTE_STATIC) {
3238                         if (bflags & BFLAGS_Static)
3239                                 if ((bflags & BFLAGS_FlattenHierarchy) || (klass == startklass))
3240                                         match++;
3241                 } else {
3242                         if (bflags & BFLAGS_Instance)
3243                                 match++;
3244                 }
3245
3246                 if (!match)
3247                         continue;
3248
3249                 utf8_name = mono_string_to_utf8 (name);
3250
3251                 if (compare_func (mono_field_get_name (field), utf8_name)) {
3252                         g_free (utf8_name);
3253                         continue;
3254                 }
3255                 g_free (utf8_name);
3256
3257                 return mono_field_get_object (domain, klass, field);
3258         }
3259         if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))
3260                 goto handle_parent;
3261
3262         return NULL;
3263 }
3264
3265 static MonoArray*
3266 ves_icall_Type_GetFields_internal (MonoReflectionType *type, guint32 bflags, MonoReflectionType *reftype)
3267 {
3268         MonoDomain *domain;
3269         MonoClass *startklass, *klass, *refklass;
3270         MonoArray *res;
3271         MonoObject *member;
3272         int i, match;
3273         gpointer iter;
3274         MonoClassField *field;
3275         MonoPtrArray tmp_array;
3276
3277         MONO_ARCH_SAVE_REGS;
3278
3279         domain = ((MonoObject *)type)->vtable->domain;
3280         if (type->type->byref)
3281                 return mono_array_new (domain, mono_defaults.field_info_class, 0);
3282         klass = startklass = mono_class_from_mono_type (type->type);
3283         refklass = mono_class_from_mono_type (reftype->type);
3284
3285         mono_ptr_array_init (tmp_array, 2);
3286
3287 handle_parent:
3288         if (klass->exception_type != MONO_EXCEPTION_NONE)
3289                 mono_raise_exception (mono_class_get_exception_for_failure (klass));
3290
3291         iter = NULL;
3292         while ((field = mono_class_get_fields (klass, &iter))) {
3293                 match = 0;
3294                 if (mono_field_is_deleted (field))
3295                         continue;
3296                 if ((field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK) == FIELD_ATTRIBUTE_PUBLIC) {
3297                         if (bflags & BFLAGS_Public)
3298                                 match++;
3299                 } else if ((klass == startklass) || (field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK) != FIELD_ATTRIBUTE_PRIVATE) {
3300                         if (bflags & BFLAGS_NonPublic) {
3301                                 match++;
3302                         }
3303                 }
3304                 if (!match)
3305                         continue;
3306                 match = 0;
3307                 if (field->type->attrs & FIELD_ATTRIBUTE_STATIC) {
3308                         if (bflags & BFLAGS_Static)
3309                                 if ((bflags & BFLAGS_FlattenHierarchy) || (klass == startklass))
3310                                         match++;
3311                 } else {
3312                         if (bflags & BFLAGS_Instance)
3313                                 match++;
3314                 }
3315
3316                 if (!match)
3317                         continue;
3318                 member = (MonoObject*)mono_field_get_object (domain, refklass, field);
3319                 mono_ptr_array_append (tmp_array, member);
3320         }
3321         if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))
3322                 goto handle_parent;
3323
3324         res = mono_array_new_cached (domain, mono_defaults.field_info_class, mono_ptr_array_size (tmp_array));
3325
3326         for (i = 0; i < mono_ptr_array_size (tmp_array); ++i)
3327                 mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i));
3328
3329         mono_ptr_array_destroy (tmp_array);
3330
3331         return res;
3332 }
3333
3334 static gboolean
3335 method_nonpublic (MonoMethod* method, gboolean start_klass)
3336 {
3337         switch (method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) {
3338                 case METHOD_ATTRIBUTE_ASSEM:
3339                         return (start_klass || mono_defaults.generic_ilist_class);
3340                 case METHOD_ATTRIBUTE_PRIVATE:
3341                         return start_klass;
3342                 case METHOD_ATTRIBUTE_PUBLIC:
3343                         return FALSE;
3344                 default:
3345                         return TRUE;
3346         }
3347 }
3348
3349 static MonoArray*
3350 ves_icall_Type_GetMethodsByName (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType *reftype)
3351 {
3352         static MonoClass *MethodInfo_array;
3353         MonoDomain *domain;
3354         MonoClass *startklass, *klass, *refklass;
3355         MonoArray *res;
3356         MonoMethod *method;
3357         gpointer iter;
3358         MonoObject *member;
3359         int i, len, match, nslots;
3360         /*FIXME, use MonoBitSet*/
3361         guint32 method_slots_default [8];
3362         guint32 *method_slots = NULL;
3363         gchar *mname = NULL;
3364         int (*compare_func) (const char *s1, const char *s2) = NULL;
3365         MonoVTable *array_vtable;
3366         MonoException *ex;
3367         MonoPtrArray tmp_array;
3368
3369         MONO_ARCH_SAVE_REGS;
3370
3371         mono_ptr_array_init (tmp_array, 4);
3372
3373         if (!MethodInfo_array) {
3374                 MonoClass *klass = mono_array_class_get (mono_defaults.method_info_class, 1);
3375                 mono_memory_barrier ();
3376                 MethodInfo_array = klass;
3377         }
3378
3379         domain = ((MonoObject *)type)->vtable->domain;
3380         array_vtable = mono_class_vtable_full (domain, MethodInfo_array, TRUE);
3381         if (type->type->byref)
3382                 return mono_array_new_specific (array_vtable, 0);
3383         klass = startklass = mono_class_from_mono_type (type->type);
3384         refklass = mono_class_from_mono_type (reftype->type);
3385         len = 0;
3386         if (name != NULL) {
3387                 mname = mono_string_to_utf8 (name);
3388                 compare_func = (ignore_case) ? mono_utf8_strcasecmp : strcmp;
3389         }
3390
3391         /* An optimization for calls made from Delegate:CreateDelegate () */
3392         if (klass->delegate && mname && !strcmp (mname, "Invoke") && (bflags == (BFLAGS_Public | BFLAGS_Static | BFLAGS_Instance))) {
3393                 method = mono_get_delegate_invoke (klass);
3394                 if (mono_loader_get_last_error ())
3395                         goto loader_error;
3396
3397                 member = (MonoObject*)mono_method_get_object (domain, method, refklass);
3398
3399                 res = mono_array_new_specific (array_vtable, 1);
3400                 mono_array_setref (res, 0, member);
3401                 g_free (mname);
3402                 return res;
3403         }
3404
3405         mono_class_setup_vtable (klass);
3406         if (klass->exception_type != MONO_EXCEPTION_NONE || mono_loader_get_last_error ())
3407                 goto loader_error;
3408
3409         if (is_generic_parameter (type->type))
3410                 nslots = mono_class_get_vtable_size (klass->parent);
3411         else
3412                 nslots = MONO_CLASS_IS_INTERFACE (klass) ? mono_class_num_methods (klass) : mono_class_get_vtable_size (klass);
3413         if (nslots >= sizeof (method_slots_default) * 8) {
3414                 method_slots = g_new0 (guint32, nslots / 32 + 1);
3415         } else {
3416                 method_slots = method_slots_default;
3417                 memset (method_slots, 0, sizeof (method_slots_default));
3418         }
3419 handle_parent:
3420         mono_class_setup_vtable (klass);
3421         if (klass->exception_type != MONO_EXCEPTION_NONE || mono_loader_get_last_error ())
3422                 goto loader_error;
3423
3424         iter = NULL;
3425         while ((method = mono_class_get_methods (klass, &iter))) {
3426                 match = 0;
3427                 if (method->slot != -1) {
3428                         g_assert (method->slot < nslots);
3429                         if (method_slots [method->slot >> 5] & (1 << (method->slot & 0x1f)))
3430                                 continue;
3431                         if (!(method->flags & METHOD_ATTRIBUTE_NEW_SLOT))
3432                                 method_slots [method->slot >> 5] |= 1 << (method->slot & 0x1f);
3433                 }
3434
3435                 if (method->name [0] == '.' && (strcmp (method->name, ".ctor") == 0 || strcmp (method->name, ".cctor") == 0))
3436                         continue;
3437                 if ((method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC) {
3438                         if (bflags & BFLAGS_Public)
3439                                 match++;
3440                 } else if ((bflags & BFLAGS_NonPublic) && method_nonpublic (method, (klass == startklass))) {
3441                                 match++;
3442                 }
3443                 if (!match)
3444                         continue;
3445                 match = 0;
3446                 if (method->flags & METHOD_ATTRIBUTE_STATIC) {
3447                         if (bflags & BFLAGS_Static)
3448                                 if ((bflags & BFLAGS_FlattenHierarchy) || (klass == startklass))
3449                                         match++;
3450                 } else {
3451                         if (bflags & BFLAGS_Instance)
3452                                 match++;
3453                 }
3454
3455                 if (!match)
3456                         continue;
3457
3458                 if (name != NULL) {
3459                         if (compare_func (mname, method->name))
3460                                 continue;
3461                 }
3462
3463                 match = 0;
3464
3465                 member = (MonoObject*)mono_method_get_object (domain, method, refklass);
3466
3467                 mono_ptr_array_append (tmp_array, member);
3468         }
3469         if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))
3470                 goto handle_parent;
3471
3472         g_free (mname);
3473         if (method_slots != method_slots_default)
3474                 g_free (method_slots);
3475
3476         res = mono_array_new_specific (array_vtable, mono_ptr_array_size (tmp_array));
3477
3478         for (i = 0; i < mono_ptr_array_size (tmp_array); ++i)
3479                 mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i));
3480
3481         mono_ptr_array_destroy (tmp_array);
3482         return res;
3483
3484 loader_error:
3485         g_free (mname);
3486         if (method_slots != method_slots_default)
3487                 g_free (method_slots);
3488         mono_ptr_array_destroy (tmp_array);
3489         if (klass->exception_type != MONO_EXCEPTION_NONE) {
3490                 ex = mono_class_get_exception_for_failure (klass);
3491         } else {
3492                 ex = mono_loader_error_prepare_exception (mono_loader_get_last_error ());
3493                 mono_loader_clear_error ();
3494         }
3495         mono_raise_exception (ex);
3496         return NULL;
3497 }
3498
3499 static MonoArray*
3500 ves_icall_Type_GetConstructors_internal (MonoReflectionType *type, guint32 bflags, MonoReflectionType *reftype)
3501 {
3502         MonoDomain *domain;
3503         static MonoClass *System_Reflection_ConstructorInfo;
3504         MonoClass *startklass, *klass, *refklass;
3505         MonoArray *res;
3506         MonoMethod *method;
3507         MonoObject *member;
3508         int i, match;
3509         gpointer iter = NULL;
3510         MonoPtrArray tmp_array;
3511
3512         MONO_ARCH_SAVE_REGS;
3513
3514         mono_ptr_array_init (tmp_array, 4); /*FIXME, guestimating*/
3515
3516         domain = ((MonoObject *)type)->vtable->domain;
3517         if (type->type->byref)
3518                 return mono_array_new_cached (domain, mono_defaults.method_info_class, 0);
3519         klass = startklass = mono_class_from_mono_type (type->type);
3520         refklass = mono_class_from_mono_type (reftype->type);
3521
3522         if (klass->exception_type != MONO_EXCEPTION_NONE)
3523                 mono_raise_exception (mono_class_get_exception_for_failure (klass));
3524
3525         if (!System_Reflection_ConstructorInfo)
3526                 System_Reflection_ConstructorInfo = mono_class_from_name (
3527                         mono_defaults.corlib, "System.Reflection", "ConstructorInfo");
3528
3529         iter = NULL;
3530         while ((method = mono_class_get_methods (klass, &iter))) {
3531                 match = 0;
3532                 if (strcmp (method->name, ".ctor") && strcmp (method->name, ".cctor"))
3533                         continue;
3534                 if ((method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC) {
3535                         if (bflags & BFLAGS_Public)
3536                                 match++;
3537                 } else {
3538                         if (bflags & BFLAGS_NonPublic)
3539                                 match++;
3540                 }
3541                 if (!match)
3542                         continue;
3543                 match = 0;
3544                 if (method->flags & METHOD_ATTRIBUTE_STATIC) {
3545                         if (bflags & BFLAGS_Static)
3546                                 if ((bflags & BFLAGS_FlattenHierarchy) || (klass == startklass))
3547                                         match++;
3548                 } else {
3549                         if (bflags & BFLAGS_Instance)
3550                                 match++;
3551                 }
3552
3553                 if (!match)
3554                         continue;
3555                 member = (MonoObject*)mono_method_get_object (domain, method, refklass);
3556
3557                 mono_ptr_array_append (tmp_array, member);
3558         }
3559
3560         res = mono_array_new_cached (domain, System_Reflection_ConstructorInfo, mono_ptr_array_size (tmp_array));
3561
3562         for (i = 0; i < mono_ptr_array_size (tmp_array); ++i)
3563                 mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i));
3564
3565         mono_ptr_array_destroy (tmp_array);
3566
3567         return res;
3568 }
3569
3570 static guint
3571 property_hash (gconstpointer data)
3572 {
3573         MonoProperty *prop = (MonoProperty*)data;
3574
3575         return g_str_hash (prop->name);
3576 }
3577
3578 static gboolean
3579 property_equal (MonoProperty *prop1, MonoProperty *prop2)
3580 {
3581         // Properties are hide-by-name-and-signature
3582         if (!g_str_equal (prop1->name, prop2->name))
3583                 return FALSE;
3584
3585         if (prop1->get && prop2->get && !mono_metadata_signature_equal (mono_method_signature (prop1->get), mono_method_signature (prop2->get)))
3586                 return FALSE;
3587         if (prop1->set && prop2->set && !mono_metadata_signature_equal (mono_method_signature (prop1->set), mono_method_signature (prop2->set)))
3588                 return FALSE;
3589         return TRUE;
3590 }
3591
3592 static gboolean
3593 property_accessor_nonpublic (MonoMethod* accessor, gboolean start_klass)
3594 {
3595         if (!accessor)
3596                 return FALSE;
3597
3598         return method_nonpublic (accessor, start_klass);
3599 }
3600
3601 static MonoArray*
3602 ves_icall_Type_GetPropertiesByName (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType *reftype)
3603 {
3604         MonoDomain *domain;
3605         static MonoClass *System_Reflection_PropertyInfo;
3606         MonoClass *startklass, *klass;
3607         MonoArray *res;
3608         MonoMethod *method;
3609         MonoProperty *prop;
3610         int i, match;
3611         guint32 flags;
3612         gchar *propname = NULL;
3613         int (*compare_func) (const char *s1, const char *s2) = NULL;
3614         gpointer iter;
3615         GHashTable *properties;
3616         MonoPtrArray tmp_array;
3617
3618         MONO_ARCH_SAVE_REGS;
3619
3620         mono_ptr_array_init (tmp_array, 8); /*This the average for ASP.NET types*/
3621
3622         if (!System_Reflection_PropertyInfo)
3623                 System_Reflection_PropertyInfo = mono_class_from_name (
3624                         mono_defaults.corlib, "System.Reflection", "PropertyInfo");
3625
3626         domain = ((MonoObject *)type)->vtable->domain;
3627         if (type->type->byref)
3628                 return mono_array_new_cached (domain, System_Reflection_PropertyInfo, 0);
3629         klass = startklass = mono_class_from_mono_type (type->type);
3630         if (name != NULL) {
3631                 propname = mono_string_to_utf8 (name);
3632                 compare_func = (ignore_case) ? mono_utf8_strcasecmp : strcmp;
3633         }
3634
3635         mono_class_setup_vtable (klass);
3636
3637         properties = g_hash_table_new (property_hash, (GEqualFunc)property_equal);
3638 handle_parent:
3639         mono_class_setup_vtable (klass);
3640         if (klass->exception_type != MONO_EXCEPTION_NONE) {
3641                 g_hash_table_destroy (properties);
3642                 if (name != NULL)
3643                         g_free (propname);
3644                 mono_raise_exception (mono_class_get_exception_for_failure (klass));
3645         }
3646
3647         iter = NULL;
3648         while ((prop = mono_class_get_properties (klass, &iter))) {
3649                 match = 0;
3650                 method = prop->get;
3651                 if (!method)
3652                         method = prop->set;
3653                 if (method)
3654                         flags = method->flags;
3655                 else
3656                         flags = 0;
3657                 if ((prop->get && ((prop->get->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC)) ||
3658                         (prop->set && ((prop->set->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC))) {
3659                         if (bflags & BFLAGS_Public)
3660                                 match++;
3661                 } else if (bflags & BFLAGS_NonPublic) {
3662                         if (property_accessor_nonpublic(prop->get, startklass == klass) ||
3663                                 property_accessor_nonpublic(prop->set, startklass == klass)) {
3664                                 match++;
3665                         }
3666                 }
3667                 if (!match)
3668                         continue;
3669                 match = 0;
3670                 if (flags & METHOD_ATTRIBUTE_STATIC) {
3671                         if (bflags & BFLAGS_Static)
3672                                 if ((bflags & BFLAGS_FlattenHierarchy) || (klass == startklass))
3673                                         match++;
3674                 } else {
3675                         if (bflags & BFLAGS_Instance)
3676                                 match++;
3677                 }
3678
3679                 if (!match)
3680                         continue;
3681                 match = 0;
3682
3683                 if (name != NULL) {
3684                         if (compare_func (propname, prop->name))
3685                                 continue;
3686                 }
3687
3688                 if (g_hash_table_lookup (properties, prop))
3689                         continue;
3690
3691                 mono_ptr_array_append (tmp_array, mono_property_get_object (domain, startklass, prop));
3692
3693                 g_hash_table_insert (properties, prop, prop);
3694         }
3695         if ((!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent)))
3696                 goto handle_parent;
3697
3698         g_hash_table_destroy (properties);
3699         g_free (propname);
3700
3701         res = mono_array_new_cached (domain, System_Reflection_PropertyInfo, mono_ptr_array_size (tmp_array));
3702         for (i = 0; i < mono_ptr_array_size (tmp_array); ++i)
3703                 mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i));
3704
3705         mono_ptr_array_destroy (tmp_array);
3706
3707         return res;
3708 }
3709
3710 static MonoReflectionEvent *
3711 ves_icall_MonoType_GetEvent (MonoReflectionType *type, MonoString *name, guint32 bflags)
3712 {
3713         MonoDomain *domain;
3714         MonoClass *klass, *startklass;
3715         gpointer iter;
3716         MonoEvent *event;
3717         MonoMethod *method;
3718         gchar *event_name;
3719
3720         MONO_ARCH_SAVE_REGS;
3721
3722         event_name = mono_string_to_utf8 (name);
3723         if (type->type->byref)
3724                 return NULL;
3725         klass = startklass = mono_class_from_mono_type (type->type);
3726         domain = mono_object_domain (type);
3727
3728 handle_parent:
3729         if (klass->exception_type != MONO_EXCEPTION_NONE)
3730                 mono_raise_exception (mono_class_get_exception_for_failure (klass));
3731
3732         iter = NULL;
3733         while ((event = mono_class_get_events (klass, &iter))) {
3734                 if (strcmp (event->name, event_name))
3735                         continue;
3736
3737                 method = event->add;
3738                 if (!method)
3739                         method = event->remove;
3740                 if (!method)
3741                         method = event->raise;
3742                 if (method) {
3743                         if ((method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC) {
3744                                 if (!(bflags & BFLAGS_Public))
3745                                         continue;
3746                         } else {
3747                                 if (!(bflags & BFLAGS_NonPublic))
3748                                         continue;
3749                                 if ((klass != startklass) && (method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PRIVATE)
3750                                         continue;
3751                         }
3752
3753                         if (method->flags & METHOD_ATTRIBUTE_STATIC) {
3754                                 if (!(bflags & BFLAGS_Static))
3755                                         continue;
3756                                 if (!(bflags & BFLAGS_FlattenHierarchy) && (klass != startklass))
3757                                         continue;
3758                         } else {
3759                                 if (!(bflags & BFLAGS_Instance))
3760                                         continue;
3761                         }
3762                 } else
3763                         if (!(bflags & BFLAGS_NonPublic))
3764                                 continue;
3765
3766                 g_free (event_name);
3767                 return mono_event_get_object (domain, startklass, event);
3768         }
3769
3770         if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))
3771                 goto handle_parent;
3772
3773         g_free (event_name);
3774         return NULL;
3775 }
3776
3777 static MonoArray*
3778 ves_icall_Type_GetEvents_internal (MonoReflectionType *type, guint32 bflags, MonoReflectionType *reftype)
3779 {
3780         MonoDomain *domain;
3781         static MonoClass *System_Reflection_EventInfo;
3782         MonoClass *startklass, *klass;
3783         MonoArray *res;
3784         MonoMethod *method;
3785         MonoEvent *event;
3786         int i, match;
3787         gpointer iter;
3788
3789         MonoPtrArray tmp_array;
3790
3791         MONO_ARCH_SAVE_REGS;
3792
3793         mono_ptr_array_init (tmp_array, 4);
3794
3795         if (!System_Reflection_EventInfo)
3796                 System_Reflection_EventInfo = mono_class_from_name (
3797                         mono_defaults.corlib, "System.Reflection", "EventInfo");
3798
3799         domain = mono_object_domain (type);
3800         if (type->type->byref)
3801                 return mono_array_new_cached (domain, System_Reflection_EventInfo, 0);
3802         klass = startklass = mono_class_from_mono_type (type->type);
3803
3804 handle_parent:
3805         if (klass->exception_type != MONO_EXCEPTION_NONE)
3806                 mono_raise_exception (mono_class_get_exception_for_failure (klass));
3807
3808         iter = NULL;
3809         while ((event = mono_class_get_events (klass, &iter))) {
3810                 match = 0;
3811                 method = event->add;
3812                 if (!method)
3813                         method = event->remove;
3814                 if (!method)
3815                         method = event->raise;
3816                 if (method) {
3817                         if ((method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC) {
3818                                 if (bflags & BFLAGS_Public)
3819                                         match++;
3820                         } else if ((klass == startklass) || (method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) != METHOD_ATTRIBUTE_PRIVATE) {
3821                                 if (bflags & BFLAGS_NonPublic)
3822                                         match++;
3823                         }
3824                 }
3825                 else
3826                         if (bflags & BFLAGS_NonPublic)
3827                                 match ++;
3828                 if (!match)
3829                         continue;
3830                 match = 0;
3831                 if (method) {
3832                         if (method->flags & METHOD_ATTRIBUTE_STATIC) {
3833                                 if (bflags & BFLAGS_Static)
3834                                         if ((bflags & BFLAGS_FlattenHierarchy) || (klass == startklass))
3835                                                 match++;
3836                         } else {
3837                                 if (bflags & BFLAGS_Instance)
3838                                         match++;
3839                         }
3840                 }
3841                 else
3842                         if (bflags & BFLAGS_Instance)
3843                                 match ++;
3844                 if (!match)
3845                         continue;
3846                 mono_ptr_array_append (tmp_array, mono_event_get_object (domain, startklass, event));
3847         }
3848         if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))
3849                 goto handle_parent;
3850
3851         res = mono_array_new_cached (domain, System_Reflection_EventInfo, mono_ptr_array_size (tmp_array));
3852
3853         for (i = 0; i < mono_ptr_array_size (tmp_array); ++i)
3854                 mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i));
3855
3856         mono_ptr_array_destroy (tmp_array);
3857
3858         return res;
3859 }
3860
3861 static MonoReflectionType *
3862 ves_icall_Type_GetNestedType (MonoReflectionType *type, MonoString *name, guint32 bflags)
3863 {
3864         MonoDomain *domain;
3865         MonoClass *klass;
3866         MonoClass *nested;
3867         char *str;
3868         gpointer iter;
3869
3870         MONO_ARCH_SAVE_REGS;
3871
3872         if (name == NULL)
3873                 mono_raise_exception (mono_get_exception_argument_null ("name"));
3874
3875         domain = ((MonoObject *)type)->vtable->domain;
3876         if (type->type->byref)
3877                 return NULL;
3878         klass = mono_class_from_mono_type (type->type);
3879         str = mono_string_to_utf8 (name);
3880
3881  handle_parent:
3882         if (klass->exception_type != MONO_EXCEPTION_NONE)
3883                 mono_raise_exception (mono_class_get_exception_for_failure (klass));
3884
3885         /*
3886          * If a nested type is generic, return its generic type definition.
3887          * Note that this means that the return value is essentially a
3888          * nested type of the generic type definition of @klass.
3889          *
3890          * A note in MSDN claims that a generic type definition can have
3891          * nested types that aren't generic.  In any case, the container of that
3892          * nested type would be the generic type definition.
3893          */
3894         if (klass->generic_class)
3895                 klass = klass->generic_class->container_class;
3896
3897         iter = NULL;
3898         while ((nested = mono_class_get_nested_types (klass, &iter))) {
3899                 int match = 0;
3900                 if ((nested->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK) == TYPE_ATTRIBUTE_NESTED_PUBLIC) {
3901                         if (bflags & BFLAGS_Public)
3902                                 match++;
3903                 } else {
3904                         if (bflags & BFLAGS_NonPublic)
3905                                 match++;
3906                 }
3907                 if (!match)
3908                         continue;
3909                 if (strcmp (nested->name, str) == 0){
3910                         g_free (str);
3911                         return mono_type_get_object (domain, &nested->byval_arg);
3912                 }
3913         }
3914         if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))
3915                 goto handle_parent;
3916         g_free (str);
3917         return NULL;
3918 }
3919
3920 static MonoArray*
3921 ves_icall_Type_GetNestedTypes (MonoReflectionType *type, guint32 bflags)
3922 {
3923         MonoDomain *domain;
3924         MonoClass *klass;
3925         MonoArray *res;
3926         MonoObject *member;
3927         int i, match;
3928         MonoClass *nested;
3929         gpointer iter;
3930         MonoPtrArray tmp_array;
3931
3932         MONO_ARCH_SAVE_REGS;
3933
3934         domain = ((MonoObject *)type)->vtable->domain;
3935         if (type->type->byref)
3936                 return mono_array_new (domain, mono_defaults.monotype_class, 0);
3937         klass = mono_class_from_mono_type (type->type);
3938         if (klass->exception_type != MONO_EXCEPTION_NONE)
3939                 mono_raise_exception (mono_class_get_exception_for_failure (klass));
3940
3941         /*
3942          * If a nested type is generic, return its generic type definition.
3943          * Note that this means that the return value is essentially the set
3944          * of nested types of the generic type definition of @klass.
3945          *
3946          * A note in MSDN claims that a generic type definition can have
3947          * nested types that aren't generic.  In any case, the container of that
3948          * nested type would be the generic type definition.
3949          */
3950         if (klass->generic_class)
3951                 klass = klass->generic_class->container_class;
3952
3953         mono_ptr_array_init (tmp_array, 1);
3954         iter = NULL;
3955         while ((nested = mono_class_get_nested_types (klass, &iter))) {
3956                 match = 0;
3957                 if ((nested->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK) == TYPE_ATTRIBUTE_NESTED_PUBLIC) {
3958                         if (bflags & BFLAGS_Public)
3959                                 match++;
3960                 } else {
3961                         if (bflags & BFLAGS_NonPublic)
3962                                 match++;
3963                 }
3964                 if (!match)
3965                         continue;
3966                 member = (MonoObject*)mono_type_get_object (domain, &nested->byval_arg);
3967                 mono_ptr_array_append (tmp_array, member);
3968         }
3969
3970         res = mono_array_new_cached (domain, mono_defaults.monotype_class, mono_ptr_array_size (tmp_array));
3971
3972         for (i = 0; i < mono_ptr_array_size (tmp_array); ++i)
3973                 mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i));
3974
3975         mono_ptr_array_destroy (tmp_array);
3976
3977         return res;
3978 }
3979
3980 static MonoReflectionType*
3981 ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssembly *assembly, MonoReflectionModule *module, MonoString *name, MonoBoolean throwOnError, MonoBoolean ignoreCase)
3982 {
3983         gchar *str;
3984         MonoType *type = NULL;
3985         MonoTypeNameParse info;
3986         gboolean type_resolve;
3987
3988         MONO_ARCH_SAVE_REGS;
3989
3990         /* On MS.NET, this does not fire a TypeResolve event */
3991         type_resolve = TRUE;
3992         str = mono_string_to_utf8 (name);
3993         /*g_print ("requested type %s in %s\n", str, assembly->assembly->aname.name);*/
3994         if (!mono_reflection_parse_type (str, &info)) {
3995                 g_free (str);
3996                 mono_reflection_free_type_info (&info);
3997                 if (throwOnError) /* uhm: this is a parse error, though... */
3998                         mono_raise_exception (mono_get_exception_type_load (name, NULL));
3999                 /*g_print ("failed parse\n");*/
4000                 return NULL;
4001         }
4002
4003         if (info.assembly.name) {
4004                 g_free (str);
4005                 mono_reflection_free_type_info (&info);
4006                 if (throwOnError) {
4007                         /* 1.0 and 2.0 throw different exceptions */
4008                         if (mono_defaults.generic_ilist_class)
4009                                 mono_raise_exception (mono_get_exception_argument (NULL, "Type names passed to Assembly.GetType() must not specify an assembly."));
4010                         else
4011                                 mono_raise_exception (mono_get_exception_type_load (name, NULL));
4012                 }
4013                 return NULL;
4014         }
4015
4016         if (module != NULL) {
4017                 if (module->image)
4018                         type = mono_reflection_get_type (module->image, &info, ignoreCase, &type_resolve);
4019                 else
4020                         type = NULL;
4021         }
4022         else
4023                 if (assembly->assembly->dynamic) {
4024                         /* Enumerate all modules */
4025                         MonoReflectionAssemblyBuilder *abuilder = (MonoReflectionAssemblyBuilder*)assembly;
4026                         int i;
4027
4028                         type = NULL;
4029                         if (abuilder->modules) {
4030                                 for (i = 0; i < mono_array_length (abuilder->modules); ++i) {
4031                                         MonoReflectionModuleBuilder *mb = mono_array_get (abuilder->modules, MonoReflectionModuleBuilder*, i);
4032                                         type = mono_reflection_get_type (&mb->dynamic_image->image, &info, ignoreCase, &type_resolve);
4033                                         if (type)
4034                                                 break;
4035                                 }
4036                         }
4037
4038                         if (!type && abuilder->loaded_modules) {
4039                                 for (i = 0; i < mono_array_length (abuilder->loaded_modules); ++i) {
4040                                         MonoReflectionModule *mod = mono_array_get (abuilder->loaded_modules, MonoReflectionModule*, i);
4041                                         type = mono_reflection_get_type (mod->image, &info, ignoreCase, &type_resolve);
4042                                         if (type)
4043                                                 break;
4044                                 }
4045                         }
4046                 }
4047                 else
4048                         type = mono_reflection_get_type (assembly->assembly->image, &info, ignoreCase, &type_resolve);
4049         g_free (str);
4050         mono_reflection_free_type_info (&info);
4051         if (!type) {
4052                 MonoException *e = NULL;
4053
4054                 if (throwOnError)
4055                         e = mono_get_exception_type_load (name, NULL);
4056
4057                 if (mono_loader_get_last_error () && mono_defaults.generic_ilist_class)
4058                         e = mono_loader_error_prepare_exception (mono_loader_get_last_error ());
4059
4060                 mono_loader_clear_error ();
4061
4062                 if (e != NULL)
4063                         mono_raise_exception (e);
4064
4065                 return NULL;
4066         }
4067
4068         if (type->type == MONO_TYPE_CLASS) {
4069                 MonoClass *klass = mono_type_get_class (type);
4070
4071                 if (mono_is_security_manager_active () && !klass->exception_type)
4072                         /* Some security problems are detected during generic vtable construction */
4073                         mono_class_setup_vtable (klass);
4074                 /* need to report exceptions ? */
4075                 if (throwOnError && klass->exception_type) {
4076                         /* report SecurityException (or others) that occured when loading the assembly */
4077                         MonoException *exc = mono_class_get_exception_for_failure (klass);
4078                         mono_loader_clear_error ();
4079                         mono_raise_exception (exc);
4080                 } else if (klass->exception_type == MONO_EXCEPTION_SECURITY_INHERITANCEDEMAND) {
4081                         return NULL;
4082                 }
4083         }
4084
4085         /* g_print ("got it\n"); */
4086         return mono_type_get_object (mono_object_domain (assembly), type);
4087 }
4088
4089 static gboolean
4090 replace_shadow_path (MonoDomain *domain, gchar *dirname, gchar **filename)
4091 {
4092         gchar *content;
4093         gchar *shadow_ini_file;
4094         gsize len;
4095
4096         /* Check for shadow-copied assembly */
4097         if (mono_is_shadow_copy_enabled (domain, dirname)) {
4098                 shadow_ini_file = g_build_filename (dirname, "__AssemblyInfo__.ini", NULL);
4099                 content = NULL;
4100                 if (!g_file_get_contents (shadow_ini_file, &content, &len, NULL) ||
4101                         !g_file_test (content, G_FILE_TEST_IS_REGULAR)) {
4102                         if (content) {
4103                                 g_free (content);
4104                                 content = NULL;
4105                         }
4106                 }
4107                 g_free (shadow_ini_file);
4108                 if (content != NULL) {
4109                         if (*filename)
4110                                 g_free (*filename);
4111                         *filename = content;
4112                         return TRUE;
4113                 }
4114         }
4115         return FALSE;
4116 }
4117
4118 static MonoString *
4119 ves_icall_System_Reflection_Assembly_get_code_base (MonoReflectionAssembly *assembly, MonoBoolean escaped)
4120 {
4121         MonoDomain *domain = mono_object_domain (assembly);
4122         MonoAssembly *mass = assembly->assembly;
4123         MonoString *res = NULL;
4124         gchar *uri;
4125         gchar *absolute;
4126         gchar *dirname;
4127
4128         MONO_ARCH_SAVE_REGS;
4129
4130         if (g_path_is_absolute (mass->image->name)) {
4131                 absolute = g_strdup (mass->image->name);
4132                 dirname = g_path_get_dirname (absolute);
4133         } else {
4134                 absolute = g_build_filename (mass->basedir, mass->image->name, NULL);
4135                 dirname = g_strdup (mass->basedir);
4136         }
4137
4138         replace_shadow_path (domain, dirname, &absolute);
4139         g_free (dirname);
4140 #if HOST_WIN32
4141         {
4142                 gint i;
4143                 for (i = strlen (absolute) - 1; i >= 0; i--)
4144                         if (absolute [i] == '\\')
4145                                 absolute [i] = '/';
4146         }
4147 #endif
4148         if (escaped) {
4149                 uri = g_filename_to_uri (absolute, NULL, NULL);
4150         } else {
4151                 const char *prepend = "file://";
4152 #if HOST_WIN32
4153                 if (*absolute == '/' && *(absolute + 1) == '/') {
4154                         prepend = "file:";
4155                 } else {
4156                         prepend = "file:///";
4157                 }
4158 #endif
4159                 uri = g_strconcat (prepend, absolute, NULL);
4160         }
4161
4162         if (uri) {
4163                 res = mono_string_new (domain, uri);
4164                 g_free (uri);
4165         }
4166         g_free (absolute);
4167         return res;
4168 }
4169
4170 static MonoBoolean
4171 ves_icall_System_Reflection_Assembly_get_global_assembly_cache (MonoReflectionAssembly *assembly)
4172 {
4173         MonoAssembly *mass = assembly->assembly;
4174
4175         MONO_ARCH_SAVE_REGS;
4176
4177         return mass->in_gac;
4178 }
4179
4180 static MonoReflectionAssembly*
4181 ves_icall_System_Reflection_Assembly_load_with_partial_name (MonoString *mname, MonoObject *evidence)
4182 {
4183         gchar *name;
4184         MonoAssembly *res;
4185         MonoImageOpenStatus status;
4186
4187         MONO_ARCH_SAVE_REGS;
4188
4189         name = mono_string_to_utf8 (mname);
4190         res = mono_assembly_load_with_partial_name (name, &status);
4191
4192         g_free (name);
4193
4194         if (res == NULL)
4195                 return NULL;
4196         return mono_assembly_get_object (mono_domain_get (), res);
4197 }
4198
4199 static MonoString *
4200 ves_icall_System_Reflection_Assembly_get_location (MonoReflectionAssembly *assembly)
4201 {
4202         MonoDomain *domain = mono_object_domain (assembly);
4203         MonoString *res;
4204
4205         MONO_ARCH_SAVE_REGS;
4206
4207         res = mono_string_new (domain, mono_image_get_filename (assembly->assembly->image));
4208
4209         return res;
4210 }
4211
4212 static MonoBoolean
4213 ves_icall_System_Reflection_Assembly_get_ReflectionOnly (MonoReflectionAssembly *assembly)
4214 {
4215         MONO_ARCH_SAVE_REGS;
4216
4217         return assembly->assembly->ref_only;
4218 }
4219
4220 static MonoString *
4221 ves_icall_System_Reflection_Assembly_InternalImageRuntimeVersion (MonoReflectionAssembly *assembly)
4222 {
4223         MonoDomain *domain = mono_object_domain (assembly);
4224
4225         MONO_ARCH_SAVE_REGS;
4226
4227         return mono_string_new (domain, assembly->assembly->image->version);
4228 }
4229
4230 static MonoReflectionMethod*
4231 ves_icall_System_Reflection_Assembly_get_EntryPoint (MonoReflectionAssembly *assembly)
4232 {
4233         guint32 token = mono_image_get_entry_point (assembly->assembly->image);
4234
4235         MONO_ARCH_SAVE_REGS;
4236
4237         if (!token)
4238                 return NULL;
4239         return mono_method_get_object (mono_object_domain (assembly), mono_get_method (assembly->assembly->image, token, NULL), NULL);
4240 }
4241
4242 static MonoReflectionModule*
4243 ves_icall_System_Reflection_Assembly_GetManifestModuleInternal (MonoReflectionAssembly *assembly)
4244 {
4245         return mono_module_get_object (mono_object_domain (assembly), assembly->assembly->image);
4246 }
4247
4248 static MonoArray*
4249 ves_icall_System_Reflection_Assembly_GetManifestResourceNames (MonoReflectionAssembly *assembly)
4250 {
4251         MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
4252         MonoArray *result = mono_array_new (mono_object_domain (assembly), mono_defaults.string_class, table->rows);
4253         int i;
4254         const char *val;
4255
4256         MONO_ARCH_SAVE_REGS;
4257
4258         for (i = 0; i < table->rows; ++i) {
4259                 val = mono_metadata_string_heap (assembly->assembly->image, mono_metadata_decode_row_col (table, i, MONO_MANIFEST_NAME));
4260                 mono_array_setref (result, i, mono_string_new (mono_object_domain (assembly), val));
4261         }
4262         return result;
4263 }
4264
4265 static MonoObject*
4266 create_version (MonoDomain *domain, guint32 major, guint32 minor, guint32 build, guint32 revision)
4267 {
4268         static MonoClass *System_Version = NULL;
4269         static MonoMethod *create_version = NULL;
4270         MonoObject *result;
4271         gpointer args [4];
4272
4273         if (!System_Version) {
4274                 System_Version = mono_class_from_name (mono_defaults.corlib, "System", "Version");
4275                 g_assert (System_Version);
4276         }
4277
4278         if (!create_version) {
4279                 MonoMethodDesc *desc = mono_method_desc_new (":.ctor(int,int,int,int)", FALSE);
4280                 create_version = mono_method_desc_search_in_class (desc, System_Version);
4281                 g_assert (create_version);
4282                 mono_method_desc_free (desc);
4283         }
4284
4285         args [0] = &major;
4286         args [1] = &minor;
4287         args [2] = &build;
4288         args [3] = &revision;
4289         result = mono_object_new (domain, System_Version);
4290         mono_runtime_invoke (create_version, result, args, NULL);
4291
4292         return result;
4293 }
4294
4295 static MonoArray*
4296 ves_icall_System_Reflection_Assembly_GetReferencedAssemblies (MonoReflectionAssembly *assembly)
4297 {
4298         static MonoClass *System_Reflection_AssemblyName;
4299         MonoArray *result;
4300         MonoDomain *domain = mono_object_domain (assembly);
4301         int i, count = 0;
4302         static MonoMethod *create_culture = NULL;
4303         MonoImage *image = assembly->assembly->image;
4304         MonoTableInfo *t;
4305
4306         MONO_ARCH_SAVE_REGS;
4307
4308         if (!System_Reflection_AssemblyName)
4309                 System_Reflection_AssemblyName = mono_class_from_name (
4310                         mono_defaults.corlib, "System.Reflection", "AssemblyName");
4311
4312         t = &assembly->assembly->image->tables [MONO_TABLE_ASSEMBLYREF];
4313         count = t->rows;
4314
4315         result = mono_array_new (domain, System_Reflection_AssemblyName, count);
4316
4317         if (count > 0 && !create_culture) {
4318                 MonoMethodDesc *desc = mono_method_desc_new (
4319                         "System.Globalization.CultureInfo:CreateCulture(string,bool)", TRUE);
4320                 create_culture = mono_method_desc_search_in_image (desc, mono_defaults.corlib);
4321                 g_assert (create_culture);
4322                 mono_method_desc_free (desc);
4323         }
4324
4325         for (i = 0; i < count; i++) {
4326                 MonoReflectionAssemblyName *aname;
4327                 guint32 cols [MONO_ASSEMBLYREF_SIZE];
4328
4329                 mono_metadata_decode_row (t, i, cols, MONO_ASSEMBLYREF_SIZE);
4330
4331                 aname = (MonoReflectionAssemblyName *) mono_object_new (
4332                         domain, System_Reflection_AssemblyName);
4333
4334                 MONO_OBJECT_SETREF (aname, name, mono_string_new (domain, mono_metadata_string_heap (image, cols [MONO_ASSEMBLYREF_NAME])));
4335
4336                 aname->major = cols [MONO_ASSEMBLYREF_MAJOR_VERSION];
4337                 aname->minor = cols [MONO_ASSEMBLYREF_MINOR_VERSION];
4338                 aname->build = cols [MONO_ASSEMBLYREF_BUILD_NUMBER];
4339                 aname->revision = cols [MONO_ASSEMBLYREF_REV_NUMBER];
4340                 aname->flags = cols [MONO_ASSEMBLYREF_FLAGS];
4341                 aname->versioncompat = 1; /* SameMachine (default) */
4342                 aname->hashalg = ASSEMBLY_HASH_SHA1; /* SHA1 (default) */
4343                 MONO_OBJECT_SETREF (aname, version, create_version (domain, aname->major, aname->minor, aname->build, aname->revision));
4344
4345                 if (create_culture) {
4346                         gpointer args [2];
4347                         MonoBoolean assembly_ref = 1;
4348                         args [0] = mono_string_new (domain, mono_metadata_string_heap (image, cols [MONO_ASSEMBLYREF_CULTURE]));
4349                         args [1] = &assembly_ref;
4350                         MONO_OBJECT_SETREF (aname, cultureInfo, mono_runtime_invoke (create_culture, NULL, args, NULL));
4351                 }
4352
4353                 if (cols [MONO_ASSEMBLYREF_PUBLIC_KEY]) {
4354                         const gchar *pkey_ptr = mono_metadata_blob_heap (image, cols [MONO_ASSEMBLYREF_PUBLIC_KEY]);
4355                         guint32 pkey_len = mono_metadata_decode_blob_size (pkey_ptr, &pkey_ptr);
4356
4357                         if ((cols [MONO_ASSEMBLYREF_FLAGS] & ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG)) {
4358                                 /* public key token isn't copied - the class library will
4359                                 automatically generate it from the public key if required */
4360                                 MONO_OBJECT_SETREF (aname, publicKey, mono_array_new (domain, mono_defaults.byte_class, pkey_len));
4361                                 memcpy (mono_array_addr (aname->publicKey, guint8, 0), pkey_ptr, pkey_len);
4362                         } else {
4363                                 MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, pkey_len));
4364                                 memcpy (mono_array_addr (aname->keyToken, guint8, 0), pkey_ptr, pkey_len);
4365                         }
4366                 } else {
4367                         MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, 0));
4368                 }
4369
4370                 /* note: this function doesn't return the codebase on purpose (i.e. it can
4371                          be used under partial trust as path information isn't present). */
4372
4373                 mono_array_setref (result, i, aname);
4374         }
4375         return result;
4376 }
4377
4378 typedef struct {
4379         MonoArray *res;
4380         int idx;
4381 } NameSpaceInfo;
4382
4383 static void
4384 foreach_namespace (const char* key, gconstpointer val, NameSpaceInfo *info)
4385 {
4386         MonoString *name = mono_string_new (mono_object_domain (info->res), key);
4387
4388         mono_array_setref (info->res, info->idx, name);
4389         info->idx++;
4390 }
4391
4392 static MonoArray*
4393 ves_icall_System_Reflection_Assembly_GetNamespaces (MonoReflectionAssembly *assembly)
4394 {
4395         MonoImage *img = assembly->assembly->image;
4396         MonoArray *res;
4397         NameSpaceInfo info;
4398         int len;
4399
4400         MONO_ARCH_SAVE_REGS;
4401
4402         mono_image_lock (img);
4403         mono_image_init_name_cache (img);
4404
4405 RETRY_LEN:
4406         len = g_hash_table_size (img->name_cache);
4407         mono_image_unlock (img);
4408
4409         /*we can't create objects holding the image lock */
4410         res = mono_array_new (mono_object_domain (assembly), mono_defaults.string_class, len);
4411
4412         mono_image_lock (img);
4413         /*len might have changed, create a new array*/
4414         if (len != g_hash_table_size (img->name_cache))
4415                 goto RETRY_LEN;
4416
4417         info.res = res;
4418         info.idx = 0;
4419         g_hash_table_foreach (img->name_cache, (GHFunc)foreach_namespace, &info);
4420         mono_image_unlock (img);
4421
4422         return res;
4423 }
4424
4425 /* move this in some file in mono/util/ */
4426 static char *
4427 g_concat_dir_and_file (const char *dir, const char *file)
4428 {
4429         g_return_val_if_fail (dir != NULL, NULL);
4430         g_return_val_if_fail (file != NULL, NULL);
4431
4432         /*
4433          * If the directory name doesn't have a / on the end, we need
4434          * to add one so we get a proper path to the file
4435          */
4436         if (dir [strlen(dir) - 1] != G_DIR_SEPARATOR)
4437                 return g_strconcat (dir, G_DIR_SEPARATOR_S, file, NULL);
4438         else
4439                 return g_strconcat (dir, file, NULL);
4440 }
4441
4442 static void *
4443 ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (MonoReflectionAssembly *assembly, MonoString *name, gint32 *size, MonoReflectionModule **ref_module)
4444 {
4445         char *n = mono_string_to_utf8 (name);
4446         MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
4447         guint32 i;
4448         guint32 cols [MONO_MANIFEST_SIZE];
4449         guint32 impl, file_idx;
4450         const char *val;
4451         MonoImage *module;
4452
4453         MONO_ARCH_SAVE_REGS;
4454
4455         for (i = 0; i < table->rows; ++i) {
4456                 mono_metadata_decode_row (table, i, cols, MONO_MANIFEST_SIZE);
4457                 val = mono_metadata_string_heap (assembly->assembly->image, cols [MONO_MANIFEST_NAME]);
4458                 if (strcmp (val, n) == 0)
4459                         break;
4460         }
4461         g_free (n);
4462         if (i == table->rows)
4463                 return NULL;
4464         /* FIXME */
4465         impl = cols [MONO_MANIFEST_IMPLEMENTATION];
4466         if (impl) {
4467                 /*
4468                  * this code should only be called after obtaining the
4469                  * ResourceInfo and handling the other cases.
4470                  */
4471                 g_assert ((impl & MONO_IMPLEMENTATION_MASK) == MONO_IMPLEMENTATION_FILE);
4472                 file_idx = impl >> MONO_IMPLEMENTATION_BITS;
4473
4474                 module = mono_image_load_file_for_image (assembly->assembly->image, file_idx);
4475                 if (!module)
4476                         return NULL;
4477         }
4478         else
4479                 module = assembly->assembly->image;
4480
4481         mono_gc_wbarrier_generic_store (ref_module, (MonoObject*) mono_module_get_object (mono_domain_get (), module));
4482
4483         return (void*)mono_image_get_resource (module, cols [MONO_MANIFEST_OFFSET], (guint32*)size);
4484 }
4485
4486 static gboolean
4487 ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (MonoReflectionAssembly *assembly, MonoString *name, MonoManifestResourceInfo *info)
4488 {
4489         MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
4490         int i;
4491         guint32 cols [MONO_MANIFEST_SIZE];
4492         guint32 file_cols [MONO_FILE_SIZE];
4493         const char *val;
4494         char *n;
4495
4496         MONO_ARCH_SAVE_REGS;
4497
4498         n = mono_string_to_utf8 (name);
4499         for (i = 0; i < table->rows; ++i) {
4500                 mono_metadata_decode_row (table, i, cols, MONO_MANIFEST_SIZE);
4501                 val = mono_metadata_string_heap (assembly->assembly->image, cols [MONO_MANIFEST_NAME]);
4502                 if (strcmp (val, n) == 0)
4503                         break;
4504         }
4505         g_free (n);
4506         if (i == table->rows)
4507                 return FALSE;
4508
4509         if (!cols [MONO_MANIFEST_IMPLEMENTATION]) {
4510                 info->location = RESOURCE_LOCATION_EMBEDDED | RESOURCE_LOCATION_IN_MANIFEST;
4511         }
4512         else {
4513                 switch (cols [MONO_MANIFEST_IMPLEMENTATION] & MONO_IMPLEMENTATION_MASK) {
4514                 case MONO_IMPLEMENTATION_FILE:
4515                         i = cols [MONO_MANIFEST_IMPLEMENTATION] >> MONO_IMPLEMENTATION_BITS;
4516                         table = &assembly->assembly->image->tables [MONO_TABLE_FILE];
4517                         mono_metadata_decode_row (table, i - 1, file_cols, MONO_FILE_SIZE);
4518                         val = mono_metadata_string_heap (assembly->assembly->image, file_cols [MONO_FILE_NAME]);
4519                         MONO_OBJECT_SETREF (info, filename, mono_string_new (mono_object_domain (assembly), val));
4520                         if (file_cols [MONO_FILE_FLAGS] && FILE_CONTAINS_NO_METADATA)
4521                                 info->location = 0;
4522                         else
4523                                 info->location = RESOURCE_LOCATION_EMBEDDED;
4524                         break;
4525
4526                 case MONO_IMPLEMENTATION_ASSEMBLYREF:
4527                         i = cols [MONO_MANIFEST_IMPLEMENTATION] >> MONO_IMPLEMENTATION_BITS;
4528                         mono_assembly_load_reference (assembly->assembly->image, i - 1);
4529                         if (assembly->assembly->image->references [i - 1] == (gpointer)-1) {
4530                                 char *msg = g_strdup_printf ("Assembly %d referenced from assembly %s not found ", i - 1, assembly->assembly->image->name);
4531                                 MonoException *ex = mono_get_exception_file_not_found2 (msg, NULL);
4532                                 g_free (msg);
4533                                 mono_raise_exception (ex);
4534                         }
4535                         MONO_OBJECT_SETREF (info, assembly, mono_assembly_get_object (mono_domain_get (), assembly->assembly->image->references [i - 1]));
4536
4537                         /* Obtain info recursively */
4538                         ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (info->assembly, name, info);
4539                         info->location |= RESOURCE_LOCATION_ANOTHER_ASSEMBLY;
4540                         break;
4541
4542                 case MONO_IMPLEMENTATION_EXP_TYPE:
4543                         g_assert_not_reached ();
4544                         break;
4545                 }
4546         }
4547
4548         return TRUE;
4549 }
4550
4551 static MonoObject*
4552 ves_icall_System_Reflection_Assembly_GetFilesInternal (MonoReflectionAssembly *assembly, MonoString *name, MonoBoolean resource_modules)
4553 {
4554         MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_FILE];
4555         MonoArray *result = NULL;
4556         int i, count;
4557         const char *val;
4558         char *n;
4559
4560         MONO_ARCH_SAVE_REGS;
4561
4562         /* check hash if needed */
4563         if (name) {
4564                 n = mono_string_to_utf8 (name);
4565                 for (i = 0; i < table->rows; ++i) {
4566                         val = mono_metadata_string_heap (assembly->assembly->image, mono_metadata_decode_row_col (table, i, MONO_FILE_NAME));
4567                         if (strcmp (val, n) == 0) {
4568                                 MonoString *fn;
4569                                 g_free (n);
4570                                 n = g_concat_dir_and_file (assembly->assembly->basedir, val);
4571                                 fn = mono_string_new (mono_object_domain (assembly), n);
4572                                 g_free (n);
4573                                 return (MonoObject*)fn;
4574                         }
4575                 }
4576                 g_free (n);
4577                 return NULL;
4578         }
4579
4580         count = 0;
4581         for (i = 0; i < table->rows; ++i) {
4582                 if (resource_modules || !(mono_metadata_decode_row_col (table, i, MONO_FILE_FLAGS) & FILE_CONTAINS_NO_METADATA))
4583                         count ++;
4584         }
4585
4586         result = mono_array_new (mono_object_domain (assembly), mono_defaults.string_class, count);
4587
4588         count = 0;
4589         for (i = 0; i < table->rows; ++i) {
4590                 if (resource_modules || !(mono_metadata_decode_row_col (table, i, MONO_FILE_FLAGS) & FILE_CONTAINS_NO_METADATA)) {
4591                         val = mono_metadata_string_heap (assembly->assembly->image, mono_metadata_decode_row_col (table, i, MONO_FILE_NAME));
4592                         n = g_concat_dir_and_file (assembly->assembly->basedir, val);
4593                         mono_array_setref (result, count, mono_string_new (mono_object_domain (assembly), n));
4594                         g_free (n);
4595                         count ++;
4596                 }
4597         }
4598         return (MonoObject*)result;
4599 }
4600
4601 static MonoArray*
4602 ves_icall_System_Reflection_Assembly_GetModulesInternal (MonoReflectionAssembly *assembly)
4603 {
4604         MonoDomain *domain = mono_domain_get();
4605         MonoArray *res;
4606         MonoClass *klass;
4607         int i, j, file_count = 0;
4608         MonoImage **modules;
4609         guint32 module_count, real_module_count;
4610         MonoTableInfo *table;
4611         guint32 cols [MONO_FILE_SIZE];
4612         MonoImage *image = assembly->assembly->image;
4613
4614         g_assert (image != NULL);
4615         g_assert (!assembly->assembly->dynamic);
4616
4617         table = &image->tables [MONO_TABLE_FILE];
4618         file_count = table->rows;
4619
4620         modules = image->modules;
4621         module_count = image->module_count;
4622
4623         real_module_count = 0;
4624         for (i = 0; i < module_count; ++i)
4625                 if (modules [i])
4626                         real_module_count ++;
4627
4628         klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "Module");
4629         res = mono_array_new (domain, klass, 1 + real_module_count + file_count);
4630
4631         mono_array_setref (res, 0, mono_module_get_object (domain, image));
4632         j = 1;
4633         for (i = 0; i < module_count; ++i)
4634                 if (modules [i]) {
4635                         mono_array_setref (res, j, mono_module_get_object (domain, modules[i]));
4636                         ++j;
4637                 }
4638
4639         for (i = 0; i < file_count; ++i, ++j) {
4640                 mono_metadata_decode_row (table, i, cols, MONO_FILE_SIZE);
4641                 if (cols [MONO_FILE_FLAGS] && FILE_CONTAINS_NO_METADATA)
4642                         mono_array_setref (res, j, mono_module_file_get_object (domain, image, i));
4643                 else {
4644                         MonoImage *m = mono_image_load_file_for_image (image, i + 1);
4645                         if (!m) {
4646                                 MonoString *fname = mono_string_new (mono_domain_get (), mono_metadata_string_heap (image, cols [MONO_FILE_NAME]));
4647                                 mono_raise_exception (mono_get_exception_file_not_found2 (NULL, fname));
4648                         }
4649                         mono_array_setref (res, j, mono_module_get_object (domain, m));
4650                 }
4651         }
4652
4653         return res;
4654 }
4655
4656 static MonoReflectionMethod*
4657 ves_icall_GetCurrentMethod (void)
4658 {
4659         MonoMethod *m = mono_method_get_last_managed ();
4660
4661         while (m->is_inflated)
4662                 m = ((MonoMethodInflated*)m)->declaring;
4663
4664         return mono_method_get_object (mono_domain_get (), m, NULL);
4665 }
4666
4667
4668 static MonoMethod*
4669 mono_method_get_equivalent_method (MonoMethod *method, MonoClass *klass)
4670 {
4671         int offset = -1, i;
4672         if (method->is_inflated && ((MonoMethodInflated*)method)->context.method_inst) {
4673                 MonoMethodInflated *inflated = (MonoMethodInflated*)method;
4674                 //method is inflated, we should inflate it on the other class
4675                 MonoGenericContext ctx;
4676                 ctx.method_inst = inflated->context.method_inst;
4677                 ctx.class_inst = inflated->context.class_inst;
4678                 if (klass->generic_class)
4679                         ctx.class_inst = klass->generic_class->context.class_inst;
4680                 else if (klass->generic_container)
4681                         ctx.class_inst = klass->generic_container->context.class_inst;
4682                 return mono_class_inflate_generic_method_full (inflated->declaring, klass, &ctx);
4683         }
4684
4685         mono_class_setup_methods (method->klass);
4686         if (method->klass->exception_type)
4687                 return NULL;
4688         for (i = 0; i < method->klass->method.count; ++i) {
4689                 if (method->klass->methods [i] == method) {
4690                         offset = i;
4691                         break;
4692                 }
4693         }
4694         mono_class_setup_methods (klass);
4695         if (klass->exception_type)
4696                 return NULL;
4697         g_assert (offset >= 0 && offset < klass->method.count);
4698         return klass->methods [offset];
4699 }
4700
4701 static MonoReflectionMethod*
4702 ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternalType (MonoMethod *method, MonoType *type)
4703 {
4704         MonoClass *klass;
4705         if (type) {
4706                 klass = mono_class_from_mono_type (type);
4707                 if (mono_class_get_generic_type_definition (method->klass) != mono_class_get_generic_type_definition (klass))
4708                         return NULL;
4709                 if (method->klass != klass) {
4710                         method = mono_method_get_equivalent_method (method, klass);
4711                         if (!method)
4712                                 return NULL;
4713                 }
4714         } else
4715                 klass = method->klass;
4716         return mono_method_get_object (mono_domain_get (), method, klass);
4717 }
4718
4719 static MonoReflectionMethod*
4720 ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternal (MonoMethod *method)
4721 {
4722         return mono_method_get_object (mono_domain_get (), method, NULL);
4723 }
4724
4725 static MonoReflectionMethodBody*
4726 ves_icall_System_Reflection_MethodBase_GetMethodBodyInternal (MonoMethod *method)
4727 {
4728         return mono_method_body_get_object (mono_domain_get (), method);
4729 }
4730
4731 static MonoReflectionAssembly*
4732 ves_icall_System_Reflection_Assembly_GetExecutingAssembly (void)
4733 {
4734         MonoMethod *dest = NULL;
4735
4736         MONO_ARCH_SAVE_REGS;
4737
4738         mono_stack_walk_no_il (get_executing, &dest);
4739         return mono_assembly_get_object (mono_domain_get (), dest->klass->image->assembly);
4740 }
4741
4742
4743 static MonoReflectionAssembly*
4744 ves_icall_System_Reflection_Assembly_GetEntryAssembly (void)
4745 {
4746         MonoDomain* domain = mono_domain_get ();
4747
4748         MONO_ARCH_SAVE_REGS;
4749
4750         if (!domain->entry_assembly)
4751                 return NULL;
4752
4753         return mono_assembly_get_object (domain, domain->entry_assembly);
4754 }
4755
4756 static MonoReflectionAssembly*
4757 ves_icall_System_Reflection_Assembly_GetCallingAssembly (void)
4758 {
4759         MonoMethod *m;
4760         MonoMethod *dest;
4761
4762         MONO_ARCH_SAVE_REGS;
4763
4764         dest = NULL;
4765         mono_stack_walk_no_il (get_executing, &dest);
4766         m = dest;
4767         mono_stack_walk_no_il (get_caller, &dest);
4768         if (!dest)
4769                 dest = m;
4770         return mono_assembly_get_object (mono_domain_get (), dest->klass->image->assembly);
4771 }
4772
4773 static MonoString *
4774 ves_icall_System_MonoType_getFullName (MonoReflectionType *object, gboolean full_name,
4775                                        gboolean assembly_qualified)
4776 {
4777         MonoDomain *domain = mono_object_domain (object);
4778         MonoTypeNameFormat format;
4779         MonoString *res;
4780         gchar *name;
4781
4782         MONO_ARCH_SAVE_REGS;
4783         if (full_name)
4784                 format = assembly_qualified ?
4785                         MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED :
4786                         MONO_TYPE_NAME_FORMAT_FULL_NAME;
4787         else
4788                 format = MONO_TYPE_NAME_FORMAT_REFLECTION;
4789
4790         name = mono_type_get_name_full (object->type, format);
4791         if (!name)
4792                 return NULL;
4793
4794         if (full_name && (object->type->type == MONO_TYPE_VAR || object->type->type == MONO_TYPE_MVAR)) {
4795                 g_free (name);
4796                 return NULL;
4797         }
4798
4799         res = mono_string_new (domain, name);
4800         g_free (name);
4801
4802         return res;
4803 }
4804
4805 static int
4806 vell_icall_MonoType_get_core_clr_security_level (MonoReflectionType *this)
4807 {
4808         MonoClass *klass = mono_class_from_mono_type (this->type);
4809         return mono_security_core_clr_class_level (klass);
4810 }
4811
4812 static void
4813 fill_reflection_assembly_name (MonoDomain *domain, MonoReflectionAssemblyName *aname, MonoAssemblyName *name, const char *absolute, gboolean by_default_version, gboolean default_publickey, gboolean default_token)
4814 {
4815         static MonoMethod *create_culture = NULL;
4816         gpointer args [2];
4817         guint32 pkey_len;
4818         const char *pkey_ptr;
4819         gchar *codebase;
4820         MonoBoolean assembly_ref = 0;
4821
4822         MONO_ARCH_SAVE_REGS;
4823
4824         MONO_OBJECT_SETREF (aname, name, mono_string_new (domain, name->name));
4825         aname->major = name->major;
4826         aname->minor = name->minor;
4827         aname->build = name->build;
4828         aname->flags = name->flags;
4829         aname->revision = name->revision;
4830         aname->hashalg = name->hash_alg;
4831         aname->versioncompat = 1; /* SameMachine (default) */
4832
4833         if (by_default_version)
4834                 MONO_OBJECT_SETREF (aname, version, create_version (domain, name->major, name->minor, name->build, name->revision));
4835
4836         codebase = NULL;
4837         if (absolute != NULL && *absolute != '\0') {
4838                 const gchar *prepend = "file://";
4839                 gchar *result;
4840
4841                 codebase = g_strdup (absolute);
4842
4843 #if HOST_WIN32
4844                 {
4845                         gint i;
4846                         for (i = strlen (codebase) - 1; i >= 0; i--)
4847                                 if (codebase [i] == '\\')
4848                                         codebase [i] = '/';
4849
4850                         if (*codebase == '/' && *(codebase + 1) == '/') {
4851                                 prepend = "file:";
4852                         } else {
4853                                 prepend = "file:///";
4854                         }
4855                 }
4856 #endif
4857                 result = g_strconcat (prepend, codebase, NULL);
4858                 g_free (codebase);
4859                 codebase = result;
4860         }
4861
4862         if (codebase) {
4863                 MONO_OBJECT_SETREF (aname, codebase, mono_string_new (domain, codebase));
4864                 g_free (codebase);
4865         }
4866
4867         if (!create_culture) {
4868                 MonoMethodDesc *desc = mono_method_desc_new ("System.Globalization.CultureInfo:CreateCulture(string,bool)", TRUE);
4869                 create_culture = mono_method_desc_search_in_image (desc, mono_defaults.corlib);
4870                 g_assert (create_culture);
4871                 mono_method_desc_free (desc);
4872         }
4873
4874         if (name->culture) {
4875                 args [0] = mono_string_new (domain, name->culture);
4876                 args [1] = &assembly_ref;
4877                 MONO_OBJECT_SETREF (aname, cultureInfo, mono_runtime_invoke (create_culture, NULL, args, NULL));
4878         }
4879
4880         if (name->public_key) {
4881                 pkey_ptr = (char*)name->public_key;
4882                 pkey_len = mono_metadata_decode_blob_size (pkey_ptr, &pkey_ptr);
4883
4884                 MONO_OBJECT_SETREF (aname, publicKey, mono_array_new (domain, mono_defaults.byte_class, pkey_len));
4885                 memcpy (mono_array_addr (aname->publicKey, guint8, 0), pkey_ptr, pkey_len);
4886                 aname->flags |= ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG;
4887         } else if (default_publickey) {
4888                 MONO_OBJECT_SETREF (aname, publicKey, mono_array_new (domain, mono_defaults.byte_class, 0));
4889                 aname->flags |= ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG;
4890         }
4891
4892         /* MonoAssemblyName keeps the public key token as an hexadecimal string */
4893         if (name->public_key_token [0]) {
4894                 int i, j;
4895                 char *p;
4896
4897                 MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, 8));
4898                 p = mono_array_addr (aname->keyToken, char, 0);
4899
4900                 for (i = 0, j = 0; i < 8; i++) {
4901                         *p = g_ascii_xdigit_value (name->public_key_token [j++]) << 4;
4902                         *p |= g_ascii_xdigit_value (name->public_key_token [j++]);
4903                         p++;
4904                 }
4905         } else if (default_token) {
4906                 MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, 0));
4907         }
4908 }
4909
4910 static MonoString *
4911 ves_icall_System_Reflection_Assembly_get_fullName (MonoReflectionAssembly *assembly)
4912 {
4913         MonoDomain *domain = mono_object_domain (assembly);
4914         MonoAssembly *mass = assembly->assembly;
4915         MonoString *res;
4916         gchar *name;
4917
4918         name = g_strdup_printf (
4919                 "%s, Version=%d.%d.%d.%d, Culture=%s, PublicKeyToken=%s%s",
4920                 mass->aname.name,
4921                 mass->aname.major, mass->aname.minor, mass->aname.build, mass->aname.revision,
4922                 mass->aname.culture && *mass->aname.culture? mass->aname.culture: "neutral",
4923                 mass->aname.public_key_token [0] ? (char *)mass->aname.public_key_token : "null",
4924                 (mass->aname.flags & ASSEMBLYREF_RETARGETABLE_FLAG) ? ", Retargetable=Yes" : "");
4925
4926         res = mono_string_new (domain, name);
4927         g_free (name);
4928
4929         return res;
4930 }
4931
4932 static void
4933 ves_icall_System_Reflection_Assembly_FillName (MonoReflectionAssembly *assembly, MonoReflectionAssemblyName *aname)
4934 {
4935         gchar *absolute;
4936         MonoAssembly *mass = assembly->assembly;
4937
4938         MONO_ARCH_SAVE_REGS;
4939
4940         if (g_path_is_absolute (mass->image->name)) {
4941                 fill_reflection_assembly_name (mono_object_domain (assembly),
4942                         aname, &mass->aname, mass->image->name, TRUE,
4943                         TRUE, TRUE);
4944                 return;
4945         }
4946         absolute = g_build_filename (mass->basedir, mass->image->name, NULL);
4947
4948         fill_reflection_assembly_name (mono_object_domain (assembly),
4949                 aname, &mass->aname, absolute, TRUE, TRUE,
4950                 TRUE);
4951
4952         g_free (absolute);
4953 }
4954
4955 static void
4956 ves_icall_System_Reflection_Assembly_InternalGetAssemblyName (MonoString *fname, MonoReflectionAssemblyName *aname)
4957 {
4958         char *filename;
4959         MonoImageOpenStatus status = MONO_IMAGE_OK;
4960         gboolean res;
4961         MonoImage *image;
4962         MonoAssemblyName name;
4963         char *dirname
4964
4965         MONO_ARCH_SAVE_REGS;
4966
4967         filename = mono_string_to_utf8 (fname);
4968
4969         dirname = g_path_get_dirname (filename);
4970         replace_shadow_path (mono_domain_get (), dirname, &filename);
4971         g_free (dirname);
4972
4973         image = mono_image_open (filename, &status);
4974
4975         if (!image){
4976                 MonoException *exc;
4977
4978                 g_free (filename);
4979                 if (status == MONO_IMAGE_IMAGE_INVALID)
4980                         exc = mono_get_exception_bad_image_format2 (NULL, fname);
4981                 else
4982                         exc = mono_get_exception_file_not_found2 (NULL, fname);
4983                 mono_raise_exception (exc);
4984         }
4985
4986         res = mono_assembly_fill_assembly_name (image, &name);
4987         if (!res) {
4988                 mono_image_close (image);
4989                 g_free (filename);
4990                 mono_raise_exception (mono_get_exception_argument ("assemblyFile", "The file does not contain a manifest"));
4991         }
4992
4993         fill_reflection_assembly_name (mono_domain_get (), aname, &name, filename,
4994                 TRUE, FALSE, TRUE);
4995
4996         g_free (filename);
4997         mono_image_close (image);
4998 }
4999
5000 static MonoBoolean
5001 ves_icall_System_Reflection_Assembly_LoadPermissions (MonoReflectionAssembly *assembly,
5002         char **minimum, guint32 *minLength, char **optional, guint32 *optLength, char **refused, guint32 *refLength)
5003 {
5004         MonoBoolean result = FALSE;
5005         MonoDeclSecurityEntry entry;
5006
5007         /* SecurityAction.RequestMinimum */
5008         if (mono_declsec_get_assembly_action (assembly->assembly, SECURITY_ACTION_REQMIN, &entry)) {
5009                 *minimum = entry.blob;
5010                 *minLength = entry.size;
5011                 result = TRUE;
5012         }
5013         /* SecurityAction.RequestOptional */
5014         if (mono_declsec_get_assembly_action (assembly->assembly, SECURITY_ACTION_REQOPT, &entry)) {
5015                 *optional = entry.blob;
5016                 *optLength = entry.size;
5017                 result = TRUE;
5018         }
5019         /* SecurityAction.RequestRefuse */
5020         if (mono_declsec_get_assembly_action (assembly->assembly, SECURITY_ACTION_REQREFUSE, &entry)) {
5021                 *refused = entry.blob;
5022                 *refLength = entry.size;
5023                 result = TRUE;
5024         }
5025
5026         return result;
5027 }
5028
5029 static MonoArray*
5030 mono_module_get_types (MonoDomain *domain, MonoImage *image, MonoArray **exceptions, MonoBoolean exportedOnly)
5031 {
5032         MonoArray *res;
5033         MonoClass *klass;
5034         MonoTableInfo *tdef = &image->tables [MONO_TABLE_TYPEDEF];
5035         int i, count;
5036         guint32 attrs, visibility;
5037
5038         /* we start the count from 1 because we skip the special type <Module> */
5039         if (exportedOnly) {
5040                 count = 0;
5041                 for (i = 1; i < tdef->rows; ++i) {
5042                         attrs = mono_metadata_decode_row_col (tdef, i, MONO_TYPEDEF_FLAGS);
5043                         visibility = attrs & TYPE_ATTRIBUTE_VISIBILITY_MASK;
5044                         if (visibility == TYPE_ATTRIBUTE_PUBLIC || visibility == TYPE_ATTRIBUTE_NESTED_PUBLIC)
5045                                 count++;
5046                 }
5047         } else {
5048                 count = tdef->rows - 1;
5049         }
5050         res = mono_array_new (domain, mono_defaults.monotype_class, count);
5051         *exceptions = mono_array_new (domain, mono_defaults.exception_class, count);
5052         count = 0;
5053         for (i = 1; i < tdef->rows; ++i) {
5054                 attrs = mono_metadata_decode_row_col (tdef, i, MONO_TYPEDEF_FLAGS);
5055                 visibility = attrs & TYPE_ATTRIBUTE_VISIBILITY_MASK;
5056                 if (!exportedOnly || (visibility == TYPE_ATTRIBUTE_PUBLIC || visibility == TYPE_ATTRIBUTE_NESTED_PUBLIC)) {
5057                         klass = mono_class_get (image, (i + 1) | MONO_TOKEN_TYPE_DEF);
5058                         if (klass) {
5059                                 mono_array_setref (res, count, mono_type_get_object (domain, &klass->byval_arg));
5060                         } else {
5061                                 MonoLoaderError *error;
5062                                 MonoException *ex;
5063
5064                                 error = mono_loader_get_last_error ();
5065                                 g_assert (error != NULL);
5066
5067                                 ex = mono_loader_error_prepare_exception (error);
5068                                 mono_array_setref (*exceptions, count, ex);
5069                         }
5070                         if (mono_loader_get_last_error ())
5071                                 mono_loader_clear_error ();
5072                         count++;
5073                 }
5074         }
5075
5076         return res;
5077 }
5078
5079 static MonoArray*
5080 ves_icall_System_Reflection_Assembly_GetTypes (MonoReflectionAssembly *assembly, MonoBoolean exportedOnly)
5081 {
5082         MonoArray *res = NULL;
5083         MonoArray *exceptions = NULL;
5084         MonoImage *image = NULL;
5085         MonoTableInfo *table = NULL;
5086         MonoDomain *domain;
5087         GList *list = NULL;
5088         int i, len, ex_count;
5089
5090         MONO_ARCH_SAVE_REGS;
5091
5092         domain = mono_object_domain (assembly);
5093
5094         g_assert (!assembly->assembly->dynamic);
5095         image = assembly->assembly->image;
5096         table = &image->tables [MONO_TABLE_FILE];
5097         res = mono_module_get_types (domain, image, &exceptions, exportedOnly);
5098
5099         /* Append data from all modules in the assembly */
5100         for (i = 0; i < table->rows; ++i) {
5101                 if (!(mono_metadata_decode_row_col (table, i, MONO_FILE_FLAGS) & FILE_CONTAINS_NO_METADATA)) {
5102                         MonoImage *loaded_image = mono_assembly_load_module (image->assembly, i + 1);
5103                         if (loaded_image) {
5104                                 MonoArray *ex2;
5105                                 MonoArray *res2 = mono_module_get_types (domain, loaded_image, &ex2, exportedOnly);
5106                                 /* Append the new types to the end of the array */
5107                                 if (mono_array_length (res2) > 0) {
5108                                         guint32 len1, len2;
5109                                         MonoArray *res3, *ex3;
5110
5111                                         len1 = mono_array_length (res);
5112                                         len2 = mono_array_length (res2);
5113
5114                                         res3 = mono_array_new (domain, mono_defaults.monotype_class, len1 + len2);
5115                                         mono_array_memcpy_refs (res3, 0, res, 0, len1);
5116                                         mono_array_memcpy_refs (res3, len1, res2, 0, len2);
5117                                         res = res3;
5118
5119                                         ex3 = mono_array_new (domain, mono_defaults.monotype_class, len1 + len2);
5120                                         mono_array_memcpy_refs (ex3, 0, exceptions, 0, len1);
5121                                         mono_array_memcpy_refs (ex3, len1, ex2, 0, len2);
5122                                         exceptions = ex3;
5123                                 }
5124                         }
5125                 }
5126         }
5127
5128         /* the ReflectionTypeLoadException must have all the types (Types property),
5129          * NULL replacing types which throws an exception. The LoaderException must
5130          * contain all exceptions for NULL items.
5131          */
5132
5133         len = mono_array_length (res);
5134
5135         ex_count = 0;
5136         for (i = 0; i < len; i++) {
5137                 MonoReflectionType *t = mono_array_get (res, gpointer, i);
5138                 MonoClass *klass;
5139
5140                 if (t) {
5141                         klass = mono_type_get_class (t->type);
5142                         if ((klass != NULL) && klass->exception_type) {
5143                                 /* keep the class in the list */
5144                                 list = g_list_append (list, klass);
5145                                 /* and replace Type with NULL */
5146                                 mono_array_setref (res, i, NULL);
5147                         }
5148                 } else {
5149                         ex_count ++;
5150                 }
5151         }
5152
5153         if (list || ex_count) {
5154                 GList *tmp = NULL;
5155                 MonoException *exc = NULL;
5156                 MonoArray *exl = NULL;
5157                 int j, length = g_list_length (list) + ex_count;
5158
5159                 mono_loader_clear_error ();
5160
5161                 exl = mono_array_new (domain, mono_defaults.exception_class, length);
5162                 /* Types for which mono_class_get () succeeded */
5163                 for (i = 0, tmp = list; tmp; i++, tmp = tmp->next) {
5164                         MonoException *exc = mono_class_get_exception_for_failure (tmp->data);
5165                         mono_array_setref (exl, i, exc);
5166                 }
5167                 /* Types for which it don't */
5168                 for (j = 0; j < mono_array_length (exceptions); ++j) {
5169                         MonoException *exc = mono_array_get (exceptions, MonoException*, j);
5170                         if (exc) {
5171                                 g_assert (i < length);
5172                                 mono_array_setref (exl, i, exc);
5173                                 i ++;
5174                         }
5175                 }
5176                 g_list_free (list);
5177                 list = NULL;
5178
5179                 exc = mono_get_exception_reflection_type_load (res, exl);
5180                 mono_loader_clear_error ();
5181                 mono_raise_exception (exc);
5182         }
5183
5184         return res;
5185 }
5186
5187 static gboolean
5188 ves_icall_System_Reflection_AssemblyName_ParseName (MonoReflectionAssemblyName *name, MonoString *assname)
5189 {
5190         MonoAssemblyName aname;
5191         MonoDomain *domain = mono_object_domain (name);
5192         char *val;
5193         gboolean is_version_defined;
5194         gboolean is_token_defined;
5195
5196         aname.public_key = NULL;
5197         val = mono_string_to_utf8 (assname);
5198         if (!mono_assembly_name_parse_full (val, &aname, TRUE, &is_version_defined, &is_token_defined)) {
5199                 g_free ((guint8*) aname.public_key);
5200                 g_free (val);
5201                 return FALSE;
5202         }
5203
5204         fill_reflection_assembly_name (domain, name, &aname, "", is_version_defined,
5205                 FALSE, is_token_defined);
5206
5207         mono_assembly_name_free (&aname);
5208         g_free ((guint8*) aname.public_key);
5209         g_free (val);
5210
5211         return TRUE;
5212 }
5213
5214 static MonoReflectionType*
5215 ves_icall_System_Reflection_Module_GetGlobalType (MonoReflectionModule *module)
5216 {
5217         MonoDomain *domain = mono_object_domain (module);
5218         MonoClass *klass;
5219
5220         MONO_ARCH_SAVE_REGS;
5221
5222         g_assert (module->image);
5223
5224         if (module->image->dynamic && ((MonoDynamicImage*)(module->image))->initial_image)
5225                 /* These images do not have a global type */
5226                 return NULL;
5227
5228         klass = mono_class_get (module->image, 1 | MONO_TOKEN_TYPE_DEF);
5229         return mono_type_get_object (domain, &klass->byval_arg);
5230 }
5231
5232 static void
5233 ves_icall_System_Reflection_Module_Close (MonoReflectionModule *module)
5234 {
5235         /*if (module->image)
5236                 mono_image_close (module->image);*/
5237 }
5238
5239 static MonoString*
5240 ves_icall_System_Reflection_Module_GetGuidInternal (MonoReflectionModule *module)
5241 {
5242         MonoDomain *domain = mono_object_domain (module);
5243
5244         MONO_ARCH_SAVE_REGS;
5245
5246         g_assert (module->image);
5247         return mono_string_new (domain, module->image->guid);
5248 }
5249
5250 static gpointer
5251 ves_icall_System_Reflection_Module_GetHINSTANCE (MonoReflectionModule *module)
5252 {
5253 #ifdef HOST_WIN32
5254         if (module->image && module->image->is_module_handle)
5255                 return module->image->raw_data;
5256 #endif
5257
5258         return (gpointer) (-1);
5259 }
5260
5261 static void
5262 ves_icall_System_Reflection_Module_GetPEKind (MonoImage *image, gint32 *pe_kind, gint32 *machine)
5263 {
5264         if (image->dynamic) {
5265                 MonoDynamicImage *dyn = (MonoDynamicImage*)image;
5266                 *pe_kind = dyn->pe_kind;
5267                 *machine = dyn->machine;
5268         }
5269         else {
5270                 *pe_kind = ((MonoCLIImageInfo*)(image->image_info))->cli_cli_header.ch_flags & 0x3;
5271                 *machine = ((MonoCLIImageInfo*)(image->image_info))->cli_header.coff.coff_machine;
5272         }
5273 }
5274
5275 static gint32
5276 ves_icall_System_Reflection_Module_GetMDStreamVersion (MonoImage *image)
5277 {
5278         return (image->md_version_major << 16) | (image->md_version_minor);
5279 }
5280
5281 static MonoArray*
5282 ves_icall_System_Reflection_Module_InternalGetTypes (MonoReflectionModule *module)
5283 {
5284         MonoArray *exceptions;
5285         int i;
5286
5287         MONO_ARCH_SAVE_REGS;
5288
5289         if (!module->image)
5290                 return mono_array_new (mono_object_domain (module), mono_defaults.monotype_class, 0);
5291         else {
5292                 MonoArray *res = mono_module_get_types (mono_object_domain (module), module->image, &exceptions, FALSE);
5293                 for (i = 0; i < mono_array_length (exceptions); ++i) {
5294                         MonoException *ex = mono_array_get (exceptions, MonoException *, i);
5295                         if (ex)
5296                                 mono_raise_exception (ex);
5297                 }
5298                 return res;
5299         }
5300 }
5301
5302 static gboolean
5303 mono_metadata_memberref_is_method (MonoImage *image, guint32 token)
5304 {
5305         guint32 cols [MONO_MEMBERREF_SIZE];
5306         const char *sig;
5307         mono_metadata_decode_row (&image->tables [MONO_TABLE_MEMBERREF], mono_metadata_token_index (token) - 1, cols, MONO_MEMBERREF_SIZE);
5308         sig = mono_metadata_blob_heap (image, cols [MONO_MEMBERREF_SIGNATURE]);
5309         mono_metadata_decode_blob_size (sig, &sig);
5310         return (*sig != 0x6);
5311 }
5312
5313 static void
5314 init_generic_context_from_args (MonoGenericContext *context, MonoArray *type_args, MonoArray *method_args)
5315 {
5316         if (type_args)
5317                 context->class_inst = mono_metadata_get_generic_inst (mono_array_length (type_args),
5318                                                                       mono_array_addr (type_args, MonoType*, 0));
5319         else
5320                 context->class_inst = NULL;
5321         if (method_args)
5322                 context->method_inst = mono_metadata_get_generic_inst (mono_array_length (method_args),
5323                                                                        mono_array_addr (method_args, MonoType*, 0));
5324         else
5325                 context->method_inst = NULL;
5326 }
5327
5328 static MonoType*
5329 ves_icall_System_Reflection_Module_ResolveTypeToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error)
5330 {
5331         MonoClass *klass;
5332         int table = mono_metadata_token_table (token);
5333         int index = mono_metadata_token_index (token);
5334         MonoGenericContext context;
5335
5336         *error = ResolveTokenError_Other;
5337
5338         /* Validate token */
5339         if ((table != MONO_TABLE_TYPEDEF) && (table != MONO_TABLE_TYPEREF) &&
5340                 (table != MONO_TABLE_TYPESPEC)) {
5341                 *error = ResolveTokenError_BadTable;
5342                 return NULL;
5343         }
5344
5345         if (image->dynamic) {
5346                 if (type_args || method_args)
5347                         mono_raise_exception (mono_get_exception_not_implemented (NULL));
5348                 klass = mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL);
5349                 if (!klass)
5350                         return NULL;
5351                 return &klass->byval_arg;
5352         }
5353
5354         if ((index <= 0) || (index > image->tables [table].rows)) {
5355                 *error = ResolveTokenError_OutOfRange;
5356                 return NULL;
5357         }
5358
5359         init_generic_context_from_args (&context, type_args, method_args);
5360         klass = mono_class_get_full (image, token, &context);
5361
5362         if (mono_loader_get_last_error ())
5363                 mono_raise_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ()));
5364
5365         if (klass)
5366                 return &klass->byval_arg;
5367         else
5368                 return NULL;
5369 }
5370
5371 static MonoMethod*
5372 ves_icall_System_Reflection_Module_ResolveMethodToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error)
5373 {
5374         int table = mono_metadata_token_table (token);
5375         int index = mono_metadata_token_index (token);
5376         MonoGenericContext context;
5377         MonoMethod *method;
5378
5379         *error = ResolveTokenError_Other;
5380
5381         /* Validate token */
5382         if ((table != MONO_TABLE_METHOD) && (table != MONO_TABLE_METHODSPEC) &&
5383                 (table != MONO_TABLE_MEMBERREF)) {
5384                 *error = ResolveTokenError_BadTable;
5385                 return NULL;
5386         }
5387
5388         if (image->dynamic) {
5389                 if (type_args || method_args)
5390                         mono_raise_exception (mono_get_exception_not_implemented (NULL));
5391                 /* FIXME: validate memberref token type */
5392                 return mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL);
5393         }
5394
5395         if ((index <= 0) || (index > image->tables [table].rows)) {
5396                 *error = ResolveTokenError_OutOfRange;
5397                 return NULL;
5398         }
5399         if ((table == MONO_TABLE_MEMBERREF) && (!mono_metadata_memberref_is_method (image, token))) {
5400                 *error = ResolveTokenError_BadTable;
5401                 return NULL;
5402         }
5403
5404         init_generic_context_from_args (&context, type_args, method_args);
5405         method = mono_get_method_full (image, token, NULL, &context);
5406
5407         if (mono_loader_get_last_error ())
5408                 mono_raise_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ()));
5409
5410         return method;
5411 }
5412
5413 static MonoString*
5414 ves_icall_System_Reflection_Module_ResolveStringToken (MonoImage *image, guint32 token, MonoResolveTokenError *error)
5415 {
5416         int index = mono_metadata_token_index (token);
5417
5418         *error = ResolveTokenError_Other;
5419
5420         /* Validate token */
5421         if (mono_metadata_token_code (token) != MONO_TOKEN_STRING) {
5422                 *error = ResolveTokenError_BadTable;
5423                 return NULL;
5424         }
5425
5426         if (image->dynamic)
5427                 return mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL);
5428
5429         if ((index <= 0) || (index >= image->heap_us.size)) {
5430                 *error = ResolveTokenError_OutOfRange;
5431                 return NULL;
5432         }
5433
5434         /* FIXME: What to do if the index points into the middle of a string ? */
5435
5436         return mono_ldstr (mono_domain_get (), image, index);
5437 }
5438
5439 static MonoClassField*
5440 ves_icall_System_Reflection_Module_ResolveFieldToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error)
5441 {
5442         MonoClass *klass;
5443         int table = mono_metadata_token_table (token);
5444         int index = mono_metadata_token_index (token);
5445         MonoGenericContext context;
5446         MonoClassField *field;
5447
5448         *error = ResolveTokenError_Other;
5449
5450         /* Validate token */
5451         if ((table != MONO_TABLE_FIELD) && (table != MONO_TABLE_MEMBERREF)) {
5452                 *error = ResolveTokenError_BadTable;
5453                 return NULL;
5454         }
5455
5456         if (image->dynamic) {
5457                 if (type_args || method_args)
5458                         mono_raise_exception (mono_get_exception_not_implemented (NULL));
5459                 /* FIXME: validate memberref token type */
5460                 return mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL);
5461         }
5462
5463         if ((index <= 0) || (index > image->tables [table].rows)) {
5464                 *error = ResolveTokenError_OutOfRange;
5465                 return NULL;
5466         }
5467         if ((table == MONO_TABLE_MEMBERREF) && (mono_metadata_memberref_is_method (image, token))) {
5468                 *error = ResolveTokenError_BadTable;
5469                 return NULL;
5470         }
5471
5472         init_generic_context_from_args (&context, type_args, method_args);
5473         field = mono_field_from_token (image, token, &klass, &context);
5474
5475         if (mono_loader_get_last_error ())
5476                 mono_raise_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ()));
5477
5478         return field;
5479 }
5480
5481
5482 static MonoObject*
5483 ves_icall_System_Reflection_Module_ResolveMemberToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error)
5484 {
5485         int table = mono_metadata_token_table (token);
5486
5487         *error = ResolveTokenError_Other;
5488
5489         switch (table) {
5490         case MONO_TABLE_TYPEDEF:
5491         case MONO_TABLE_TYPEREF:
5492         case MONO_TABLE_TYPESPEC: {
5493                 MonoType *t = ves_icall_System_Reflection_Module_ResolveTypeToken (image, token, type_args, method_args, error);
5494                 if (t)
5495                         return (MonoObject*)mono_type_get_object (mono_domain_get (), t);
5496                 else
5497                         return NULL;
5498         }
5499         case MONO_TABLE_METHOD:
5500         case MONO_TABLE_METHODSPEC: {
5501                 MonoMethod *m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error);
5502                 if (m)
5503                         return (MonoObject*)mono_method_get_object (mono_domain_get (), m, m->klass);
5504                 else
5505                         return NULL;
5506         }
5507         case MONO_TABLE_FIELD: {
5508                 MonoClassField *f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error);
5509                 if (f)
5510                         return (MonoObject*)mono_field_get_object (mono_domain_get (), f->parent, f);
5511                 else
5512                         return NULL;
5513         }
5514         case MONO_TABLE_MEMBERREF:
5515                 if (mono_metadata_memberref_is_method (image, token)) {
5516                         MonoMethod *m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error);
5517                         if (m)
5518                                 return (MonoObject*)mono_method_get_object (mono_domain_get (), m, m->klass);
5519                         else
5520                                 return NULL;
5521                 }
5522                 else {
5523                         MonoClassField *f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error);
5524                         if (f)
5525                                 return (MonoObject*)mono_field_get_object (mono_domain_get (), f->parent, f);
5526                         else
5527                                 return NULL;
5528                 }
5529                 break;
5530
5531         default:
5532                 *error = ResolveTokenError_BadTable;
5533         }
5534
5535         return NULL;
5536 }
5537
5538 static MonoArray*
5539 ves_icall_System_Reflection_Module_ResolveSignature (MonoImage *image, guint32 token, MonoResolveTokenError *error)
5540 {
5541         int table = mono_metadata_token_table (token);
5542         int idx = mono_metadata_token_index (token);
5543         MonoTableInfo *tables = image->tables;
5544         guint32 sig, len;
5545         const char *ptr;
5546         MonoArray *res;
5547
5548         *error = ResolveTokenError_OutOfRange;
5549
5550         /* FIXME: Support other tables ? */
5551         if (table != MONO_TABLE_STANDALONESIG)
5552                 return NULL;
5553
5554         if (image->dynamic)
5555                 return NULL;
5556
5557         if ((idx == 0) || (idx > tables [MONO_TABLE_STANDALONESIG].rows))
5558                 return NULL;
5559
5560         sig = mono_metadata_decode_row_col (&tables [MONO_TABLE_STANDALONESIG], idx - 1, 0);
5561
5562         ptr = mono_metadata_blob_heap (image, sig);
5563         len = mono_metadata_decode_blob_size (ptr, &ptr);
5564
5565         res = mono_array_new (mono_domain_get (), mono_defaults.byte_class, len);
5566         memcpy (mono_array_addr (res, guint8, 0), ptr, len);
5567         return res;
5568 }
5569
5570 static MonoReflectionType*
5571 ves_icall_ModuleBuilder_create_modified_type (MonoReflectionTypeBuilder *tb, MonoString *smodifiers)
5572 {
5573         MonoClass *klass;
5574         int isbyref = 0, rank;
5575         char *str = mono_string_to_utf8 (smodifiers);
5576         char *p;
5577
5578         MONO_ARCH_SAVE_REGS;
5579
5580         klass = mono_class_from_mono_type (tb->type.type);
5581         p = str;
5582         /* logic taken from mono_reflection_parse_type(): keep in sync */
5583         while (*p) {
5584                 switch (*p) {
5585                 case '&':
5586                         if (isbyref) { /* only one level allowed by the spec */
5587                                 g_free (str);
5588                                 return NULL;
5589                         }
5590                         isbyref = 1;
5591                         p++;
5592                         g_free (str);
5593                         return mono_type_get_object (mono_object_domain (tb), &klass->this_arg);
5594                         break;
5595                 case '*':
5596                         klass = mono_ptr_class_get (&klass->byval_arg);
5597                         mono_class_init (klass);
5598                         p++;
5599                         break;
5600                 case '[':
5601                         rank = 1;
5602                         p++;
5603                         while (*p) {
5604                                 if (*p == ']')
5605                                         break;
5606                                 if (*p == ',')
5607                                         rank++;
5608                                 else if (*p != '*') { /* '*' means unknown lower bound */
5609                                         g_free (str);
5610                                         return NULL;
5611                                 }
5612                                 ++p;
5613                         }
5614                         if (*p != ']') {
5615                                 g_free (str);
5616                                 return NULL;
5617                         }
5618                         p++;
5619                         klass = mono_array_class_get (klass, rank);
5620                         mono_class_init (klass);
5621                         break;
5622                 default:
5623                         break;
5624                 }
5625         }
5626         g_free (str);
5627         return mono_type_get_object (mono_object_domain (tb), &klass->byval_arg);
5628 }
5629
5630 static MonoBoolean
5631 ves_icall_Type_IsArrayImpl (MonoReflectionType *t)
5632 {
5633         MonoType *type;
5634         MonoBoolean res;
5635
5636         MONO_ARCH_SAVE_REGS;
5637
5638         type = t->type;
5639         res = !type->byref && (type->type == MONO_TYPE_ARRAY || type->type == MONO_TYPE_SZARRAY);
5640
5641         return res;
5642 }
5643
5644 static MonoReflectionType *
5645 ves_icall_Type_make_array_type (MonoReflectionType *type, int rank)
5646 {
5647         MonoClass *klass, *aklass;
5648
5649         MONO_ARCH_SAVE_REGS;
5650
5651         klass = mono_class_from_mono_type (type->type);
5652         if (rank == 0) //single dimentional array
5653                 aklass = mono_array_class_get (klass, 1);
5654         else
5655                 aklass = mono_bounded_array_class_get (klass, rank, TRUE);
5656
5657         return mono_type_get_object (mono_object_domain (type), &aklass->byval_arg);
5658 }
5659
5660 static MonoReflectionType *
5661 ves_icall_Type_make_byref_type (MonoReflectionType *type)
5662 {
5663         MonoClass *klass;
5664
5665         MONO_ARCH_SAVE_REGS;
5666
5667         klass = mono_class_from_mono_type (type->type);
5668
5669         return mono_type_get_object (mono_object_domain (type), &klass->this_arg);
5670 }
5671
5672 static MonoReflectionType *
5673 ves_icall_Type_MakePointerType (MonoReflectionType *type)
5674 {
5675         MonoClass *pklass;
5676
5677         MONO_ARCH_SAVE_REGS;
5678
5679         pklass = mono_ptr_class_get (type->type);
5680
5681         return mono_type_get_object (mono_object_domain (type), &pklass->byval_arg);
5682 }
5683
5684 static MonoObject *
5685 ves_icall_System_Delegate_CreateDelegate_internal (MonoReflectionType *type, MonoObject *target,
5686                                                    MonoReflectionMethod *info, MonoBoolean throwOnBindFailure)
5687 {
5688         MonoClass *delegate_class = mono_class_from_mono_type (type->type);
5689         MonoObject *delegate;
5690         gpointer func;
5691         MonoMethod *method = info->method;
5692
5693         MONO_ARCH_SAVE_REGS;
5694
5695         mono_assert (delegate_class->parent == mono_defaults.multicastdelegate_class);
5696
5697         if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR) {
5698                 if (!mono_security_core_clr_ensure_delegate_creation (method, throwOnBindFailure))
5699                         return NULL;
5700         }
5701
5702         delegate = mono_object_new (mono_object_domain (type), delegate_class);
5703
5704         if (method->dynamic) {
5705                 /* Creating a trampoline would leak memory */
5706                 func = mono_compile_method (method);
5707         } else {
5708                 func = mono_create_ftnptr (mono_domain_get (),
5709                         mono_runtime_create_jump_trampoline (mono_domain_get (), method, TRUE));
5710         }
5711
5712         mono_delegate_ctor_with_method (delegate, target, func, method);
5713
5714         return delegate;
5715 }
5716
5717 static void
5718 ves_icall_System_Delegate_SetMulticastInvoke (MonoDelegate *this)
5719 {
5720         /* Reset the invoke impl to the default one */
5721         this->invoke_impl = mono_runtime_create_delegate_trampoline (this->object.vtable->klass);
5722 }
5723
5724 /*
5725  * Magic number to convert a time which is relative to
5726  * Jan 1, 1970 into a value which is relative to Jan 1, 0001.
5727  */
5728 #define EPOCH_ADJUST    ((guint64)62135596800LL)
5729
5730 /*
5731  * Magic number to convert FILETIME base Jan 1, 1601 to DateTime - base Jan, 1, 0001
5732  */
5733 #define FILETIME_ADJUST ((guint64)504911232000000000LL)
5734
5735 #ifdef HOST_WIN32
5736 /* convert a SYSTEMTIME which is of the form "last thursday in october" to a real date */
5737 static void
5738 convert_to_absolute_date(SYSTEMTIME *date)
5739 {
5740 #define IS_LEAP(y) ((y % 4) == 0 && ((y % 100) != 0 || (y % 400) == 0))
5741         static int days_in_month[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
5742         static int leap_days_in_month[] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
5743         /* from the calendar FAQ */
5744         int a = (14 - date->wMonth) / 12;
5745         int y = date->wYear - a;
5746         int m = date->wMonth + 12 * a - 2;
5747         int d = (1 + y + y/4 - y/100 + y/400 + (31*m)/12) % 7;
5748
5749         /* d is now the day of the week for the first of the month (0 == Sunday) */
5750
5751         int day_of_week = date->wDayOfWeek;
5752
5753         /* set day_in_month to the first day in the month which falls on day_of_week */
5754         int day_in_month = 1 + (day_of_week - d);
5755         if (day_in_month <= 0)
5756                 day_in_month += 7;
5757
5758         /* wDay is 1 for first weekday in month, 2 for 2nd ... 5 means last - so work that out allowing for days in the month */
5759         date->wDay = day_in_month + (date->wDay - 1) * 7;
5760         if (date->wDay > (IS_LEAP(date->wYear) ? leap_days_in_month[date->wMonth - 1] : days_in_month[date->wMonth - 1]))
5761                 date->wDay -= 7;
5762 }
5763 #endif
5764
5765 #ifndef HOST_WIN32
5766 /*
5767  * Return's the offset from GMT of a local time.
5768  *
5769  *  tm is a local time
5770  *  t  is the same local time as seconds.
5771  */
5772 static int
5773 gmt_offset(struct tm *tm, time_t t)
5774 {
5775 #if defined (HAVE_TM_GMTOFF)
5776         return tm->tm_gmtoff;
5777 #else
5778         struct tm g;
5779         time_t t2;
5780         g = *gmtime(&t);
5781         g.tm_isdst = tm->tm_isdst;
5782         t2 = mktime(&g);
5783         return (int)difftime(t, t2);
5784 #endif
5785 }
5786 #endif
5787 /*
5788  * This is heavily based on zdump.c from glibc 2.2.
5789  *
5790  *  * data[0]:  start of daylight saving time (in DateTime ticks).
5791  *  * data[1]:  end of daylight saving time (in DateTime ticks).
5792  *  * data[2]:  utcoffset (in TimeSpan ticks).
5793  *  * data[3]:  additional offset when daylight saving (in TimeSpan ticks).
5794  *  * name[0]:  name of this timezone when not daylight saving.
5795  *  * name[1]:  name of this timezone when daylight saving.
5796  *
5797  *  FIXME: This only works with "standard" Unix dates (years between 1900 and 2100) while
5798  *         the class library allows years between 1 and 9999.
5799  *
5800  *  Returns true on success and zero on failure.
5801  */
5802 static guint32
5803 ves_icall_System_CurrentSystemTimeZone_GetTimeZoneData (guint32 year, MonoArray **data, MonoArray **names)
5804 {
5805 #ifndef HOST_WIN32
5806         MonoDomain *domain = mono_domain_get ();
5807         struct tm start, tt;
5808         time_t t;
5809
5810         long int gmtoff;
5811         int is_daylight = 0, day;
5812         char tzone [64];
5813
5814         MONO_ARCH_SAVE_REGS;
5815
5816         MONO_CHECK_ARG_NULL (data);
5817         MONO_CHECK_ARG_NULL (names);
5818
5819         mono_gc_wbarrier_generic_store (data, (MonoObject*) mono_array_new (domain, mono_defaults.int64_class, 4));
5820         mono_gc_wbarrier_generic_store (names, (MonoObject*) mono_array_new (domain, mono_defaults.string_class, 2));
5821
5822         /*
5823          * no info is better than crashing: we'll need our own tz data
5824          * to make this work properly, anyway. The range is probably
5825          * reduced to 1970 .. 2037 because that is what mktime is
5826          * guaranteed to support (we get into an infinite loop
5827          * otherwise).
5828          */
5829
5830         memset (&start, 0, sizeof (start));
5831
5832         start.tm_mday = 1;
5833         start.tm_year = year-1900;
5834
5835         t = mktime (&start);
5836
5837         if ((year < 1970) || (year > 2037) || (t == -1)) {
5838                 t = time (NULL);
5839                 tt = *localtime (&t);
5840                 strftime (tzone, sizeof (tzone), "%Z", &tt);
5841                 mono_array_setref ((*names), 0, mono_string_new (domain, tzone));
5842                 mono_array_setref ((*names), 1, mono_string_new (domain, tzone));
5843                 return 1;
5844         }
5845
5846         gmtoff = gmt_offset (&start, t);
5847
5848         /* For each day of the year, calculate the tm_gmtoff. */
5849         for (day = 0; day < 365; day++) {
5850
5851                 t += 3600*24;
5852                 tt = *localtime (&t);
5853
5854                 /* Daylight saving starts or ends here. */
5855                 if (gmt_offset (&tt, t) != gmtoff) {
5856                         struct tm tt1;
5857                         time_t t1;
5858
5859                         /* Try to find the exact hour when daylight saving starts/ends. */
5860                         t1 = t;
5861                         do {
5862                                 t1 -= 3600;
5863                                 tt1 = *localtime (&t1);
5864                         } while (gmt_offset (&tt1, t1) != gmtoff);
5865
5866                         /* Try to find the exact minute when daylight saving starts/ends. */
5867                         do {
5868                                 t1 += 60;
5869                                 tt1 = *localtime (&t1);
5870                         } while (gmt_offset (&tt1, t1) == gmtoff);
5871                         t1+=gmtoff;
5872                         strftime (tzone, sizeof (tzone), "%Z", &tt);
5873
5874                         /* Write data, if we're already in daylight saving, we're done. */
5875                         if (is_daylight) {
5876                                 mono_array_setref ((*names), 0, mono_string_new (domain, tzone));
5877                                 mono_array_set ((*data), gint64, 1, ((gint64)t1 + EPOCH_ADJUST) * 10000000L);
5878                                 return 1;
5879                         } else {
5880                                 mono_array_setref ((*names), 1, mono_string_new (domain, tzone));
5881                                 mono_array_set ((*data), gint64, 0, ((gint64)t1 + EPOCH_ADJUST) * 10000000L);
5882                                 is_daylight = 1;
5883                         }
5884
5885                         /* This is only set once when we enter daylight saving. */
5886                         mono_array_set ((*data), gint64, 2, (gint64)gmtoff * 10000000L);
5887                         mono_array_set ((*data), gint64, 3, (gint64)(gmt_offset (&tt, t) - gmtoff) * 10000000L);
5888
5889                         gmtoff = gmt_offset (&tt, t);
5890                 }
5891         }
5892
5893         if (!is_daylight) {
5894                 strftime (tzone, sizeof (tzone), "%Z", &tt);
5895                 mono_array_setref ((*names), 0, mono_string_new (domain, tzone));
5896                 mono_array_setref ((*names), 1, mono_string_new (domain, tzone));
5897                 mono_array_set ((*data), gint64, 0, 0);
5898                 mono_array_set ((*data), gint64, 1, 0);
5899                 mono_array_set ((*data), gint64, 2, (gint64) gmtoff * 10000000L);
5900                 mono_array_set ((*data), gint64, 3, 0);
5901         }
5902
5903         return 1;
5904 #else
5905         MonoDomain *domain = mono_domain_get ();
5906         TIME_ZONE_INFORMATION tz_info;
5907         FILETIME ft;
5908         int i;
5909         int err, tz_id;
5910
5911         tz_id = GetTimeZoneInformation (&tz_info);
5912         if (tz_id == TIME_ZONE_ID_INVALID)
5913                 return 0;
5914
5915         MONO_CHECK_ARG_NULL (data);
5916         MONO_CHECK_ARG_NULL (names);
5917
5918         mono_gc_wbarrier_generic_store (data, mono_array_new (domain, mono_defaults.int64_class, 4));
5919         mono_gc_wbarrier_generic_store (names, mono_array_new (domain, mono_defaults.string_class, 2));
5920
5921         for (i = 0; i < 32; ++i)
5922                 if (!tz_info.DaylightName [i])
5923                         break;
5924         mono_array_setref ((*names), 1, mono_string_new_utf16 (domain, tz_info.DaylightName, i));
5925         for (i = 0; i < 32; ++i)
5926                 if (!tz_info.StandardName [i])
5927                         break;
5928         mono_array_setref ((*names), 0, mono_string_new_utf16 (domain, tz_info.StandardName, i));
5929
5930         if ((year <= 1601) || (year > 30827)) {
5931                 /*
5932                  * According to MSDN, the MS time functions can't handle dates outside
5933                  * this interval.
5934                  */
5935                 return 1;
5936         }
5937
5938         /* even if the timezone has no daylight savings it may have Bias (e.g. GMT+13 it seems) */
5939         if (tz_id != TIME_ZONE_ID_UNKNOWN) {
5940                 tz_info.StandardDate.wYear = year;
5941                 convert_to_absolute_date(&tz_info.StandardDate);
5942                 err = SystemTimeToFileTime (&tz_info.StandardDate, &ft);
5943                 //g_assert(err);
5944                 if (err == 0)
5945                         return 0;
5946
5947                 mono_array_set ((*data), gint64, 1, FILETIME_ADJUST + (((guint64)ft.dwHighDateTime<<32) | ft.dwLowDateTime));
5948                 tz_info.DaylightDate.wYear = year;
5949                 convert_to_absolute_date(&tz_info.DaylightDate);
5950                 err = SystemTimeToFileTime (&tz_info.DaylightDate, &ft);
5951                 //g_assert(err);
5952                 if (err == 0)
5953                         return 0;
5954
5955                 mono_array_set ((*data), gint64, 0, FILETIME_ADJUST + (((guint64)ft.dwHighDateTime<<32) | ft.dwLowDateTime));
5956         }
5957         mono_array_set ((*data), gint64, 2, (tz_info.Bias + tz_info.StandardBias) * -600000000LL);
5958         mono_array_set ((*data), gint64, 3, (tz_info.DaylightBias - tz_info.StandardBias) * -600000000LL);
5959
5960         return 1;
5961 #endif
5962 }
5963
5964 static gpointer
5965 ves_icall_System_Object_obj_address (MonoObject *this)
5966 {
5967         MONO_ARCH_SAVE_REGS;
5968
5969         return this;
5970 }
5971
5972 /* System.Buffer */
5973
5974 static inline gint32
5975 mono_array_get_byte_length (MonoArray *array)
5976 {
5977         MonoClass *klass;
5978         int length;
5979         int i;
5980
5981         klass = array->obj.vtable->klass;
5982
5983         if (array->bounds == NULL)
5984                 length = array->max_length;
5985         else {
5986                 length = 1;
5987                 for (i = 0; i < klass->rank; ++ i)
5988                         length *= array->bounds [i].length;
5989         }
5990
5991         switch (klass->element_class->byval_arg.type) {
5992         case MONO_TYPE_I1:
5993         case MONO_TYPE_U1:
5994         case MONO_TYPE_BOOLEAN:
5995                 return length;
5996         case MONO_TYPE_I2:
5997         case MONO_TYPE_U2:
5998         case MONO_TYPE_CHAR:
5999                 return length << 1;
6000         case MONO_TYPE_I4:
6001         case MONO_TYPE_U4:
6002         case MONO_TYPE_R4:
6003                 return length << 2;
6004         case MONO_TYPE_I:
6005         case MONO_TYPE_U:
6006                 return length * sizeof (gpointer);
6007         case MONO_TYPE_I8:
6008         case MONO_TYPE_U8:
6009         case MONO_TYPE_R8:
6010                 return length << 3;
6011         default:
6012                 return -1;
6013         }
6014 }
6015
6016 static gint32
6017 ves_icall_System_Buffer_ByteLengthInternal (MonoArray *array)
6018 {
6019         MONO_ARCH_SAVE_REGS;
6020
6021         return mono_array_get_byte_length (array);
6022 }
6023
6024 static gint8
6025 ves_icall_System_Buffer_GetByteInternal (MonoArray *array, gint32 idx)
6026 {
6027         MONO_ARCH_SAVE_REGS;
6028
6029         return mono_array_get (array, gint8, idx);
6030 }
6031
6032 static void
6033 ves_icall_System_Buffer_SetByteInternal (MonoArray *array, gint32 idx, gint8 value)
6034 {
6035         MONO_ARCH_SAVE_REGS;
6036
6037         mono_array_set (array, gint8, idx, value);
6038 }
6039
6040 static MonoBoolean
6041 ves_icall_System_Buffer_BlockCopyInternal (MonoArray *src, gint32 src_offset, MonoArray *dest, gint32 dest_offset, gint32 count)
6042 {
6043         guint8 *src_buf, *dest_buf;
6044
6045         MONO_ARCH_SAVE_REGS;
6046
6047         /* watch out for integer overflow */
6048         if ((src_offset > mono_array_get_byte_length (src) - count) || (dest_offset > mono_array_get_byte_length (dest) - count))
6049                 return FALSE;
6050
6051         src_buf = (guint8 *)src->vector + src_offset;
6052         dest_buf = (guint8 *)dest->vector + dest_offset;
6053
6054         if (src != dest)
6055                 memcpy (dest_buf, src_buf, count);
6056         else
6057                 memmove (dest_buf, src_buf, count); /* Source and dest are the same array */
6058
6059         return TRUE;
6060 }
6061
6062 static MonoObject *
6063 ves_icall_Remoting_RealProxy_GetTransparentProxy (MonoObject *this, MonoString *class_name)
6064 {
6065         MonoDomain *domain = mono_object_domain (this);
6066         MonoObject *res;
6067         MonoRealProxy *rp = ((MonoRealProxy *)this);
6068         MonoTransparentProxy *tp;
6069         MonoType *type;
6070         MonoClass *klass;
6071
6072         MONO_ARCH_SAVE_REGS;
6073
6074         res = mono_object_new (domain, mono_defaults.transparent_proxy_class);
6075         tp = (MonoTransparentProxy*) res;
6076
6077         MONO_OBJECT_SETREF (tp, rp, rp);
6078         type = ((MonoReflectionType *)rp->class_to_proxy)->type;
6079         klass = mono_class_from_mono_type (type);
6080
6081         tp->custom_type_info = (mono_object_isinst (this, mono_defaults.iremotingtypeinfo_class) != NULL);
6082         tp->remote_class = mono_remote_class (domain, class_name, klass);
6083
6084         res->vtable = mono_remote_class_vtable (domain, tp->remote_class, rp);
6085         return res;
6086 }
6087
6088 static MonoReflectionType *
6089 ves_icall_Remoting_RealProxy_InternalGetProxyType (MonoTransparentProxy *tp)
6090 {
6091         return mono_type_get_object (mono_object_domain (tp), &tp->remote_class->proxy_class->byval_arg);
6092 }
6093
6094 /* System.Environment */
6095
6096 MonoString*
6097 ves_icall_System_Environment_get_UserName (void)
6098 {
6099         MONO_ARCH_SAVE_REGS;
6100
6101         /* using glib is more portable */
6102         return mono_string_new (mono_domain_get (), g_get_user_name ());
6103 }
6104
6105
6106 static MonoString *
6107 ves_icall_System_Environment_get_MachineName (void)
6108 {
6109 #if defined (HOST_WIN32)
6110         gunichar2 *buf;
6111         guint32 len;
6112         MonoString *result;
6113
6114         len = MAX_COMPUTERNAME_LENGTH + 1;
6115         buf = g_new (gunichar2, len);
6116
6117         result = NULL;
6118         if (GetComputerName (buf, (PDWORD) &len))
6119                 result = mono_string_new_utf16 (mono_domain_get (), buf, len);
6120
6121         g_free (buf);
6122         return result;
6123 #elif !defined(DISABLE_SOCKETS)
6124         gchar buf [256];
6125         MonoString *result;
6126
6127         if (gethostname (buf, sizeof (buf)) == 0)
6128                 result = mono_string_new (mono_domain_get (), buf);
6129         else
6130                 result = NULL;
6131
6132         return result;
6133 #else
6134         return mono_string_new (mono_domain_get (), "mono");
6135 #endif
6136 }
6137
6138 static int
6139 ves_icall_System_Environment_get_Platform (void)
6140 {
6141 #if defined (TARGET_WIN32)
6142         /* Win32NT */
6143         return 2;
6144 #elif defined(__MACH__)
6145         /* OSX */
6146         //
6147         // For compatibility with our client code, this will be 4 for a while.
6148         // We will eventually move to 6 to match .NET, but it requires all client
6149         // code to be updated and the documentation everywhere to be updated
6150         // first.
6151         //
6152         return 4;
6153 #else
6154         /* Unix */
6155         return 4;
6156 #endif
6157 }
6158
6159 static MonoString *
6160 ves_icall_System_Environment_get_NewLine (void)
6161 {
6162         MONO_ARCH_SAVE_REGS;
6163
6164 #if defined (HOST_WIN32)
6165         return mono_string_new (mono_domain_get (), "\r\n");
6166 #else
6167         return mono_string_new (mono_domain_get (), "\n");
6168 #endif
6169 }
6170
6171 static MonoString *
6172 ves_icall_System_Environment_GetEnvironmentVariable (MonoString *name)
6173 {
6174         const gchar *value;
6175         gchar *utf8_name;
6176
6177         MONO_ARCH_SAVE_REGS;
6178
6179         if (name == NULL)
6180                 return NULL;
6181
6182         utf8_name = mono_string_to_utf8 (name); /* FIXME: this should be ascii */
6183         value = g_getenv (utf8_name);
6184
6185         g_free (utf8_name);
6186
6187         if (value == 0)
6188                 return NULL;
6189
6190         return mono_string_new (mono_domain_get (), value);
6191 }
6192
6193 /*
6194  * There is no standard way to get at environ.
6195  */
6196 #ifndef _MSC_VER
6197 #ifndef __MINGW32_VERSION
6198 #ifdef __APPLE__
6199 /* Apple defines this in crt_externs.h but doesn't provide that header for
6200  * arm-apple-darwin9.  We'll manually define the symbol on Apple as it does
6201  * in fact exist on all implementations (so far)
6202  */
6203 gchar ***_NSGetEnviron(void);
6204 #define environ (*_NSGetEnviron())
6205 #else
6206 extern
6207 char **environ;
6208 #endif
6209 #endif
6210 #endif
6211
6212 static MonoArray *
6213 ves_icall_System_Environment_GetEnvironmentVariableNames (void)
6214 {
6215 #ifdef HOST_WIN32
6216         MonoArray *names;
6217         MonoDomain *domain;
6218         MonoString *str;
6219         WCHAR* env_strings;
6220         WCHAR* env_string;
6221         WCHAR* equal_str;
6222         int n = 0;
6223
6224         env_strings = GetEnvironmentStrings();
6225
6226         if (env_strings) {
6227                 env_string = env_strings;
6228                 while (*env_string != '\0') {
6229                 /* weird case that MS seems to skip */
6230                         if (*env_string != '=')
6231                                 n++;
6232                         while (*env_string != '\0')
6233                                 env_string++;
6234                         env_string++;
6235                 }
6236         }
6237
6238         domain = mono_domain_get ();
6239         names = mono_array_new (domain, mono_defaults.string_class, n);
6240
6241         if (env_strings) {
6242                 n = 0;
6243                 env_string = env_strings;
6244                 while (*env_string != '\0') {
6245                         /* weird case that MS seems to skip */
6246                         if (*env_string != '=') {
6247                                 equal_str = wcschr(env_string, '=');
6248                                 g_assert(equal_str);
6249                                 str = mono_string_new_utf16 (domain, env_string, equal_str-env_string);
6250                                 mono_array_setref (names, n, str);
6251                                 n++;
6252                         }
6253                         while (*env_string != '\0')
6254                                 env_string++;
6255                         env_string++;
6256                 }
6257
6258                 FreeEnvironmentStrings (env_strings);
6259         }
6260
6261         return names;
6262
6263 #else
6264         MonoArray *names;
6265         MonoDomain *domain;
6266         MonoString *str;
6267         gchar **e, **parts;
6268         int n;
6269
6270         MONO_ARCH_SAVE_REGS;
6271
6272         n = 0;
6273         for (e = environ; *e != 0; ++ e)
6274                 ++ n;
6275
6276         domain = mono_domain_get ();
6277         names = mono_array_new (domain, mono_defaults.string_class, n);
6278
6279         n = 0;
6280         for (e = environ; *e != 0; ++ e) {
6281                 parts = g_strsplit (*e, "=", 2);
6282                 if (*parts != 0) {
6283                         str = mono_string_new (domain, *parts);
6284                         mono_array_setref (names, n, str);
6285                 }
6286
6287                 g_strfreev (parts);
6288
6289                 ++ n;
6290         }
6291
6292         return names;
6293 #endif
6294 }
6295
6296 /*
6297  * If your platform lacks setenv/unsetenv, you must upgrade your glib.
6298  */
6299 #if !GLIB_CHECK_VERSION(2,4,0)
6300 #define g_setenv(a,b,c)   setenv(a,b,c)
6301 #define g_unsetenv(a) unsetenv(a)
6302 #endif
6303
6304 static void
6305 ves_icall_System_Environment_InternalSetEnvironmentVariable (MonoString *name, MonoString *value)
6306 {
6307         MonoError error;
6308 #ifdef HOST_WIN32
6309
6310         gunichar2 *utf16_name, *utf16_value;
6311 #else
6312         gchar *utf8_name, *utf8_value;
6313 #endif
6314
6315         MONO_ARCH_SAVE_REGS;
6316
6317 #ifdef HOST_WIN32
6318         utf16_name = mono_string_to_utf16 (name);
6319         if ((value == NULL) || (mono_string_length (value) == 0) || (mono_string_chars (value)[0] == 0)) {
6320                 SetEnvironmentVariable (utf16_name, NULL);
6321                 g_free (utf16_name);
6322                 return;
6323         }
6324
6325         utf16_value = mono_string_to_utf16 (value);
6326
6327         SetEnvironmentVariable (utf16_name, utf16_value);
6328
6329         g_free (utf16_name);
6330         g_free (utf16_value);
6331 #else
6332         utf8_name = mono_string_to_utf8 (name); /* FIXME: this should be ascii */
6333
6334         if ((value == NULL) || (mono_string_length (value) == 0) || (mono_string_chars (value)[0] == 0)) {
6335                 g_unsetenv (utf8_name);
6336                 g_free (utf8_name);
6337                 return;
6338         }
6339
6340         utf8_value = mono_string_to_utf8_checked (value, &error);
6341         if (!mono_error_ok (&error)) {
6342                 g_free (utf8_name);
6343                 mono_error_raise_exception (&error);
6344         }
6345         g_setenv (utf8_name, utf8_value, TRUE);
6346
6347         g_free (utf8_name);
6348         g_free (utf8_value);
6349 #endif
6350 }
6351
6352 static void
6353 ves_icall_System_Environment_Exit (int result)
6354 {
6355         MONO_ARCH_SAVE_REGS;
6356
6357         mono_threads_set_shutting_down ();
6358
6359         mono_runtime_set_shutting_down ();
6360
6361         /* This will kill the tp threads which cannot be suspended */
6362         mono_thread_pool_cleanup ();
6363
6364         /* Suspend all managed threads since the runtime is going away */
6365         mono_thread_suspend_all_other_threads ();
6366
6367         mono_runtime_quit ();
6368
6369         /* we may need to do some cleanup here... */
6370         exit (result);
6371 }
6372
6373 static MonoString*
6374 ves_icall_System_Environment_GetGacPath (void)
6375 {
6376         return mono_string_new (mono_domain_get (), mono_assembly_getrootdir ());
6377 }
6378
6379 static MonoString*
6380 ves_icall_System_Environment_GetWindowsFolderPath (int folder)
6381 {
6382 #if defined (HOST_WIN32)
6383         #ifndef CSIDL_FLAG_CREATE
6384                 #define CSIDL_FLAG_CREATE       0x8000
6385         #endif
6386
6387         WCHAR path [MAX_PATH];
6388         /* Create directory if no existing */
6389         if (SUCCEEDED (SHGetFolderPathW (NULL, folder | CSIDL_FLAG_CREATE, NULL, 0, path))) {
6390                 int len = 0;
6391                 while (path [len])
6392                         ++ len;
6393                 return mono_string_new_utf16 (mono_domain_get (), path, len);
6394         }
6395 #else
6396         g_warning ("ves_icall_System_Environment_GetWindowsFolderPath should only be called on Windows!");
6397 #endif
6398         return mono_string_new (mono_domain_get (), "");
6399 }
6400
6401 static MonoArray *
6402 ves_icall_System_Environment_GetLogicalDrives (void)
6403 {
6404         gunichar2 buf [128], *ptr, *dname;
6405         gunichar2 *u16;
6406         guint initial_size = 127, size = 128;
6407         gint ndrives;
6408         MonoArray *result;
6409         MonoString *drivestr;
6410         MonoDomain *domain = mono_domain_get ();
6411         gint len;
6412
6413         MONO_ARCH_SAVE_REGS;
6414
6415         buf [0] = '\0';
6416         ptr = buf;
6417
6418         while (size > initial_size) {
6419                 size = (guint) GetLogicalDriveStrings (initial_size, ptr);
6420                 if (size > initial_size) {
6421                         if (ptr != buf)
6422                                 g_free (ptr);
6423                         ptr = g_malloc0 ((size + 1) * sizeof (gunichar2));
6424                         initial_size = size;
6425                         size++;
6426                 }
6427         }
6428
6429         /* Count strings */
6430         dname = ptr;
6431         ndrives = 0;
6432         do {
6433                 while (*dname++);
6434                 ndrives++;
6435         } while (*dname);
6436
6437         dname = ptr;
6438         result = mono_array_new (domain, mono_defaults.string_class, ndrives);
6439         ndrives = 0;
6440         do {
6441                 len = 0;
6442                 u16 = dname;
6443                 while (*u16) { u16++; len ++; }
6444                 drivestr = mono_string_new_utf16 (domain, dname, len);
6445                 mono_array_setref (result, ndrives++, drivestr);
6446                 while (*dname++);
6447         } while (*dname);
6448
6449         if (ptr != buf)
6450                 g_free (ptr);
6451
6452         return result;
6453 }
6454
6455 static MonoString *
6456 ves_icall_System_Environment_InternalGetHome (void)
6457 {
6458         MONO_ARCH_SAVE_REGS;
6459
6460         return mono_string_new (mono_domain_get (), g_get_home_dir ());
6461 }
6462
6463 static const char *encodings [] = {
6464         (char *) 1,
6465                 "ascii", "us_ascii", "us", "ansi_x3.4_1968",
6466                 "ansi_x3.4_1986", "cp367", "csascii", "ibm367",
6467                 "iso_ir_6", "iso646_us", "iso_646.irv:1991",
6468         (char *) 2,
6469                 "utf_7", "csunicode11utf7", "unicode_1_1_utf_7",
6470                 "unicode_2_0_utf_7", "x_unicode_1_1_utf_7",
6471                 "x_unicode_2_0_utf_7",
6472         (char *) 3,
6473                 "utf_8", "unicode_1_1_utf_8", "unicode_2_0_utf_8",
6474                 "x_unicode_1_1_utf_8", "x_unicode_2_0_utf_8",
6475         (char *) 4,
6476                 "utf_16", "UTF_16LE", "ucs_2", "unicode",
6477                 "iso_10646_ucs2",
6478         (char *) 5,
6479                 "unicodefffe", "utf_16be",
6480         (char *) 6,
6481                 "iso_8859_1",
6482         (char *) 0
6483 };
6484
6485 /*
6486  * Returns the internal codepage, if the value of "int_code_page" is
6487  * 1 at entry, and we can not compute a suitable code page number,
6488  * returns the code page as a string
6489  */
6490 static MonoString*
6491 ves_icall_System_Text_Encoding_InternalCodePage (gint32 *int_code_page)
6492 {
6493         const char *cset;
6494         const char *p;
6495         char *c;
6496         char *codepage = NULL;
6497         int code;
6498         int want_name = *int_code_page;
6499         int i;
6500
6501         *int_code_page = -1;
6502         MONO_ARCH_SAVE_REGS;
6503
6504         g_get_charset (&cset);
6505         c = codepage = strdup (cset);
6506         for (c = codepage; *c; c++){
6507                 if (isascii (*c) && isalpha (*c))
6508                         *c = tolower (*c);
6509                 if (*c == '-')
6510                         *c = '_';
6511         }
6512         /* g_print ("charset: %s\n", cset); */
6513
6514         /* handle some common aliases */
6515         p = encodings [0];
6516         code = 0;
6517         for (i = 0; p != 0; ){
6518                 if ((gssize) p < 7){
6519                         code = (gssize) p;
6520                         p = encodings [++i];
6521                         continue;
6522                 }
6523                 if (strcmp (p, codepage) == 0){
6524                         *int_code_page = code;
6525                         break;
6526                 }
6527                 p = encodings [++i];
6528         }
6529
6530         if (strstr (codepage, "utf_8") != NULL)
6531                 *int_code_page |= 0x10000000;
6532         free (codepage);
6533
6534         if (want_name && *int_code_page == -1)
6535                 return mono_string_new (mono_domain_get (), cset);
6536         else
6537                 return NULL;
6538 }
6539
6540 static MonoBoolean
6541 ves_icall_System_Environment_get_HasShutdownStarted (void)
6542 {
6543         if (mono_runtime_is_shutting_down ())
6544                 return TRUE;
6545
6546         if (mono_domain_is_unloading (mono_domain_get ()))
6547                 return TRUE;
6548
6549         return FALSE;
6550 }
6551
6552 static void
6553 ves_icall_System_Environment_BroadcastSettingChange (void)
6554 {
6555 #ifdef HOST_WIN32
6556         SendMessageTimeout (HWND_BROADCAST, WM_SETTINGCHANGE, NULL, L"Environment", SMTO_ABORTIFHUNG, 2000, 0);
6557 #endif
6558 }
6559
6560 static void
6561 ves_icall_MonoMethodMessage_InitMessage (MonoMethodMessage *this,
6562                                          MonoReflectionMethod *method,
6563                                          MonoArray *out_args)
6564 {
6565         MONO_ARCH_SAVE_REGS;
6566
6567         mono_message_init (mono_object_domain (this), this, method, out_args);
6568 }
6569
6570 static MonoBoolean
6571 ves_icall_IsTransparentProxy (MonoObject *proxy)
6572 {
6573         MONO_ARCH_SAVE_REGS;
6574
6575         if (!proxy)
6576                 return 0;
6577
6578         if (proxy->vtable->klass == mono_defaults.transparent_proxy_class)
6579                 return 1;
6580
6581         return 0;
6582 }
6583
6584 static MonoReflectionMethod *
6585 ves_icall_Remoting_RemotingServices_GetVirtualMethod (
6586         MonoReflectionType *rtype, MonoReflectionMethod *rmethod)
6587 {
6588         MonoClass *klass;
6589         MonoMethod *method;
6590         MonoMethod **vtable;
6591         MonoMethod *res = NULL;
6592
6593         MONO_CHECK_ARG_NULL (rtype);
6594         MONO_CHECK_ARG_NULL (rmethod);
6595
6596         method = rmethod->method;
6597         klass = mono_class_from_mono_type (rtype->type);
6598
6599         if (MONO_CLASS_IS_INTERFACE (klass))
6600                 return NULL;
6601
6602         if (method->flags & METHOD_ATTRIBUTE_STATIC)
6603                 return NULL;
6604
6605         if ((method->flags & METHOD_ATTRIBUTE_FINAL) || !(method->flags & METHOD_ATTRIBUTE_VIRTUAL)) {
6606                 if (klass == method->klass || mono_class_is_subclass_of (klass, method->klass, FALSE))
6607                         return rmethod;
6608                 else
6609                         return NULL;
6610         }
6611
6612         mono_class_setup_vtable (klass);
6613         vtable = klass->vtable;
6614
6615         if (method->klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
6616                 gboolean variance_used = FALSE;
6617                 /*MS fails with variant interfaces but it's the right thing to do anyway.*/
6618                 int offs = mono_class_interface_offset_with_variance (klass, method->klass, &variance_used);
6619                 if (offs >= 0)
6620                         res = vtable [offs + method->slot];
6621         } else {
6622                 if (!(klass == method->klass || mono_class_is_subclass_of (klass, method->klass, FALSE)))
6623                         return NULL;
6624
6625                 if (method->slot != -1)
6626                         res = vtable [method->slot];
6627         }
6628
6629         if (!res)
6630                 return NULL;
6631
6632         return mono_method_get_object (mono_domain_get (), res, NULL);
6633 }
6634
6635 static void
6636 ves_icall_System_Runtime_Activation_ActivationServices_EnableProxyActivation (MonoReflectionType *type, MonoBoolean enable)
6637 {
6638         MonoClass *klass;
6639         MonoVTable* vtable;
6640
6641         MONO_ARCH_SAVE_REGS;
6642
6643         klass = mono_class_from_mono_type (type->type);
6644         vtable = mono_class_vtable_full (mono_domain_get (), klass, TRUE);
6645
6646         if (enable) vtable->remote = 1;
6647         else vtable->remote = 0;
6648 }
6649
6650 static MonoObject *
6651 ves_icall_System_Runtime_Activation_ActivationServices_AllocateUninitializedClassInstance (MonoReflectionType *type)
6652 {
6653         MonoClass *klass;
6654         MonoDomain *domain;
6655
6656         MONO_ARCH_SAVE_REGS;
6657
6658         domain = mono_object_domain (type);
6659         klass = mono_class_from_mono_type (type->type);
6660
6661         if (klass->rank >= 1) {
6662                 g_assert (klass->rank == 1);
6663                 return (MonoObject *) mono_array_new (domain, klass->element_class, 0);
6664         } else {
6665                 /* Bypass remoting object creation check */
6666                 return mono_object_new_alloc_specific (mono_class_vtable_full (domain, klass, TRUE));
6667         }
6668 }
6669
6670 static MonoString *
6671 ves_icall_System_IO_get_temp_path (void)
6672 {
6673         MONO_ARCH_SAVE_REGS;
6674
6675         return mono_string_new (mono_domain_get (), g_get_tmp_dir ());
6676 }
6677
6678 #ifndef PLATFORM_NO_DRIVEINFO
6679 static MonoBoolean
6680 ves_icall_System_IO_DriveInfo_GetDiskFreeSpace (MonoString *path_name, guint64 *free_bytes_avail,
6681                                                 guint64 *total_number_of_bytes, guint64 *total_number_of_free_bytes,
6682                                                 gint32 *error)
6683 {
6684         gboolean result;
6685         ULARGE_INTEGER wapi_free_bytes_avail;
6686         ULARGE_INTEGER wapi_total_number_of_bytes;
6687         ULARGE_INTEGER wapi_total_number_of_free_bytes;
6688
6689         MONO_ARCH_SAVE_REGS;
6690
6691         *error = ERROR_SUCCESS;
6692         result = GetDiskFreeSpaceEx (mono_string_chars (path_name), &wapi_free_bytes_avail, &wapi_total_number_of_bytes,
6693                                      &wapi_total_number_of_free_bytes);
6694
6695         if (result) {
6696                 *free_bytes_avail = wapi_free_bytes_avail.QuadPart;
6697                 *total_number_of_bytes = wapi_total_number_of_bytes.QuadPart;
6698                 *total_number_of_free_bytes = wapi_total_number_of_free_bytes.QuadPart;
6699         } else {
6700                 *free_bytes_avail = 0;
6701                 *total_number_of_bytes = 0;
6702                 *total_number_of_free_bytes = 0;
6703                 *error = GetLastError ();
6704         }
6705
6706         return result;
6707 }
6708
6709 static guint32
6710 ves_icall_System_IO_DriveInfo_GetDriveType (MonoString *root_path_name)
6711 {
6712         MONO_ARCH_SAVE_REGS;
6713
6714         return GetDriveType (mono_string_chars (root_path_name));
6715 }
6716 #endif
6717
6718 static gpointer
6719 ves_icall_RuntimeMethod_GetFunctionPointer (MonoMethod *method)
6720 {
6721         MONO_ARCH_SAVE_REGS;
6722
6723         return mono_compile_method (method);
6724 }
6725
6726 static MonoString *
6727 ves_icall_System_Configuration_DefaultConfig_get_machine_config_path (void)
6728 {
6729         MonoString *mcpath;
6730         gchar *path;
6731
6732         MONO_ARCH_SAVE_REGS;
6733
6734         path = g_build_path (G_DIR_SEPARATOR_S, mono_get_config_dir (), "mono", mono_get_runtime_info ()->framework_version, "machine.config", NULL);
6735
6736 #if defined (HOST_WIN32)
6737         /* Avoid mixing '/' and '\\' */
6738         {
6739                 gint i;
6740                 for (i = strlen (path) - 1; i >= 0; i--)
6741                         if (path [i] == '/')
6742                                 path [i] = '\\';
6743         }
6744 #endif
6745         mcpath = mono_string_new (mono_domain_get (), path);
6746         g_free (path);
6747
6748         return mcpath;
6749 }
6750
6751 static MonoString *
6752 get_bundled_machine_config (void)
6753 {
6754         const gchar *machine_config;
6755
6756         MONO_ARCH_SAVE_REGS;
6757
6758         machine_config = mono_get_machine_config ();
6759
6760         if (!machine_config)
6761                 return NULL;
6762
6763         return mono_string_new (mono_domain_get (), machine_config);
6764 }
6765
6766 static MonoString *
6767 ves_icall_System_Web_Util_ICalls_get_machine_install_dir (void)
6768 {
6769         MonoString *ipath;
6770         gchar *path;
6771
6772         MONO_ARCH_SAVE_REGS;
6773
6774         path = g_path_get_dirname (mono_get_config_dir ());
6775
6776 #if defined (HOST_WIN32)
6777         /* Avoid mixing '/' and '\\' */
6778         {
6779                 gint i;
6780                 for (i = strlen (path) - 1; i >= 0; i--)
6781                         if (path [i] == '/')
6782                                 path [i] = '\\';
6783         }
6784 #endif
6785         ipath = mono_string_new (mono_domain_get (), path);
6786         g_free (path);
6787
6788         return ipath;
6789 }
6790
6791 static gboolean
6792 ves_icall_get_resources_ptr (MonoReflectionAssembly *assembly, gpointer *result, gint32 *size)
6793 {
6794         MonoPEResourceDataEntry *entry;
6795         MonoImage *image;
6796
6797         MONO_ARCH_SAVE_REGS;
6798
6799         if (!assembly || !result || !size)
6800                 return FALSE;
6801
6802         *result = NULL;
6803         *size = 0;
6804         image = assembly->assembly->image;
6805         entry = mono_image_lookup_resource (image, MONO_PE_RESOURCE_ID_ASPNET_STRING, 0, NULL);
6806         if (!entry)
6807                 return FALSE;
6808
6809         *result = mono_image_rva_map (image, entry->rde_data_offset);
6810         if (!(*result)) {
6811                 g_free (entry);
6812                 return FALSE;
6813         }
6814         *size = entry->rde_size;
6815         g_free (entry);
6816         return TRUE;
6817 }
6818
6819 static MonoBoolean
6820 ves_icall_System_Diagnostics_Debugger_IsAttached_internal (void)
6821 {
6822         return mono_debug_using_mono_debugger () || mono_is_debugger_attached ();
6823 }
6824
6825 static void
6826 ves_icall_System_Diagnostics_DefaultTraceListener_WriteWindowsDebugString (MonoString *message)
6827 {
6828 #if defined (HOST_WIN32)
6829         OutputDebugString (mono_string_chars (message));
6830 #else
6831         g_warning ("WriteWindowsDebugString called and HOST_WIN32 not defined!\n");
6832 #endif
6833 }
6834
6835 /* Only used for value types */
6836 static MonoObject *
6837 ves_icall_System_Activator_CreateInstanceInternal (MonoReflectionType *type)
6838 {
6839         MonoClass *klass;
6840         MonoDomain *domain;
6841
6842         MONO_ARCH_SAVE_REGS;
6843
6844         domain = mono_object_domain (type);
6845         klass = mono_class_from_mono_type (type->type);
6846
6847         if (mono_class_is_nullable (klass))
6848                 /* No arguments -> null */
6849                 return NULL;
6850
6851         return mono_object_new (domain, klass);
6852 }
6853
6854 static MonoReflectionMethod *
6855 ves_icall_MonoMethod_get_base_method (MonoReflectionMethod *m, gboolean definition)
6856 {
6857         MonoClass *klass, *parent;
6858         MonoMethod *method = m->method;
6859         MonoMethod *result = NULL;
6860
6861         MONO_ARCH_SAVE_REGS;
6862
6863         if (method->klass == NULL)
6864                 return m;
6865
6866         if (!(method->flags & METHOD_ATTRIBUTE_VIRTUAL) ||
6867             MONO_CLASS_IS_INTERFACE (method->klass) ||
6868             method->flags & METHOD_ATTRIBUTE_NEW_SLOT)
6869                 return m;
6870
6871         klass = method->klass;
6872         if (klass->generic_class)
6873                 klass = klass->generic_class->container_class;
6874
6875         if (definition) {
6876                 /* At the end of the loop, klass points to the eldest class that has this virtual function slot. */
6877                 for (parent = klass->parent; parent != NULL; parent = parent->parent) {
6878                         mono_class_setup_vtable (parent);
6879                         if (parent->vtable_size <= method->slot)
6880                                 break;
6881                         klass = parent;
6882                 }
6883         } else {
6884                 klass = klass->parent;
6885                 if (!klass)
6886                         return m;
6887         }
6888
6889         if (klass == method->klass)
6890                 return m;
6891
6892         result = klass->vtable [method->slot];
6893         if (result == NULL) {
6894                 /* It is an abstract method */
6895                 gpointer iter = NULL;
6896                 while ((result = mono_class_get_methods (klass, &iter)))
6897                         if (result->slot == method->slot)
6898                                 break;
6899         }
6900
6901         if (result == NULL)
6902                 return m;
6903
6904         return mono_method_get_object (mono_domain_get (), result, NULL);
6905 }
6906
6907 static MonoString*
6908 ves_icall_MonoMethod_get_name (MonoReflectionMethod *m)
6909 {
6910         MonoMethod *method = m->method;
6911
6912         MONO_OBJECT_SETREF (m, name, mono_string_new (mono_object_domain (m), method->name));
6913         return m->name;
6914 }
6915
6916 static void
6917 mono_ArgIterator_Setup (MonoArgIterator *iter, char* argsp, char* start)
6918 {
6919         MONO_ARCH_SAVE_REGS;
6920
6921         iter->sig = *(MonoMethodSignature**)argsp;
6922
6923         g_assert (iter->sig->sentinelpos <= iter->sig->param_count);
6924         g_assert (iter->sig->call_convention == MONO_CALL_VARARG);
6925
6926         iter->next_arg = 0;
6927         /* FIXME: it's not documented what start is exactly... */
6928         if (start) {
6929                 iter->args = start;
6930         } else {
6931                 iter->args = argsp + sizeof (gpointer);
6932         }
6933         iter->num_args = iter->sig->param_count - iter->sig->sentinelpos;
6934
6935         /* g_print ("sig %p, param_count: %d, sent: %d\n", iter->sig, iter->sig->param_count, iter->sig->sentinelpos); */
6936 }
6937
6938 static MonoTypedRef
6939 mono_ArgIterator_IntGetNextArg (MonoArgIterator *iter)
6940 {
6941         guint32 i, arg_size;
6942         gint32 align;
6943         MonoTypedRef res;
6944         MONO_ARCH_SAVE_REGS;
6945
6946         i = iter->sig->sentinelpos + iter->next_arg;
6947
6948         g_assert (i < iter->sig->param_count);
6949
6950         res.type = iter->sig->params [i];
6951         res.klass = mono_class_from_mono_type (res.type);
6952         res.value = iter->args;
6953         arg_size = mono_type_stack_size (res.type, &align);
6954 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
6955         if (arg_size <= sizeof (gpointer)) {
6956                 int dummy;
6957                 int padding = arg_size - mono_type_size (res.type, &dummy);
6958                 res.value = (guint8*)res.value + padding;
6959         }
6960 #endif
6961         iter->args = (char*)iter->args + arg_size;
6962         iter->next_arg++;
6963
6964         /* g_print ("returning arg %d, type 0x%02x of size %d at %p\n", i, res.type->type, arg_size, res.value); */
6965
6966         return res;
6967 }
6968
6969 static MonoTypedRef
6970 mono_ArgIterator_IntGetNextArgT (MonoArgIterator *iter, MonoType *type)
6971 {
6972         guint32 i, arg_size;
6973         gint32 align;
6974         MonoTypedRef res;
6975         MONO_ARCH_SAVE_REGS;
6976
6977         i = iter->sig->sentinelpos + iter->next_arg;
6978
6979         g_assert (i < iter->sig->param_count);
6980
6981         while (i < iter->sig->param_count) {
6982                 if (!mono_metadata_type_equal (type, iter->sig->params [i]))
6983                         continue;
6984                 res.type = iter->sig->params [i];
6985                 res.klass = mono_class_from_mono_type (res.type);
6986                 /* FIXME: endianess issue... */
6987                 res.value = iter->args;
6988                 arg_size = mono_type_stack_size (res.type, &align);
6989                 iter->args = (char*)iter->args + arg_size;
6990                 iter->next_arg++;
6991                 /* g_print ("returning arg %d, type 0x%02x of size %d at %p\n", i, res.type->type, arg_size, res.value); */
6992                 return res;
6993         }
6994         /* g_print ("arg type 0x%02x not found\n", res.type->type); */
6995
6996         res.type = NULL;
6997         res.value = NULL;
6998         res.klass = NULL;
6999         return res;
7000 }
7001
7002 static MonoType*
7003 mono_ArgIterator_IntGetNextArgType (MonoArgIterator *iter)
7004 {
7005         gint i;
7006         MONO_ARCH_SAVE_REGS;
7007
7008         i = iter->sig->sentinelpos + iter->next_arg;
7009
7010         g_assert (i < iter->sig->param_count);
7011
7012         return iter->sig->params [i];
7013 }
7014
7015 static MonoObject*
7016 mono_TypedReference_ToObject (MonoTypedRef tref)
7017 {
7018         MONO_ARCH_SAVE_REGS;
7019
7020         if (MONO_TYPE_IS_REFERENCE (tref.type)) {
7021                 MonoObject** objp = tref.value;
7022                 return *objp;
7023         }
7024
7025         return mono_value_box (mono_domain_get (), tref.klass, tref.value);
7026 }
7027
7028 static MonoObject*
7029 mono_TypedReference_ToObjectInternal (MonoType *type, gpointer value, MonoClass *klass)
7030 {
7031         MONO_ARCH_SAVE_REGS;
7032
7033         if (MONO_TYPE_IS_REFERENCE (type)) {
7034                 MonoObject** objp = value;
7035                 return *objp;
7036         }
7037
7038         return mono_value_box (mono_domain_get (), klass, value);
7039 }
7040
7041 static void
7042 prelink_method (MonoMethod *method)
7043 {
7044         const char *exc_class, *exc_arg;
7045         if (!(method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
7046                 return;
7047         mono_lookup_pinvoke_call (method, &exc_class, &exc_arg);
7048         if (exc_class) {
7049                 mono_raise_exception(
7050                         mono_exception_from_name_msg (mono_defaults.corlib, "System", exc_class, exc_arg ) );
7051         }
7052         /* create the wrapper, too? */
7053 }
7054
7055 static void
7056 ves_icall_System_Runtime_InteropServices_Marshal_Prelink (MonoReflectionMethod *method)
7057 {
7058         MONO_ARCH_SAVE_REGS;
7059         prelink_method (method->method);
7060 }
7061
7062 static void
7063 ves_icall_System_Runtime_InteropServices_Marshal_PrelinkAll (MonoReflectionType *type)
7064 {
7065         MonoClass *klass = mono_class_from_mono_type (type->type);
7066         MonoMethod* m;
7067         gpointer iter = NULL;
7068         MONO_ARCH_SAVE_REGS;
7069
7070         while ((m = mono_class_get_methods (klass, &iter)))
7071                 prelink_method (m);
7072 }
7073
7074 /* These parameters are "readonly" in corlib/System/NumberFormatter.cs */
7075 static void
7076 ves_icall_System_NumberFormatter_GetFormatterTables (guint64 const **mantissas,
7077                                             gint32 const **exponents,
7078                                             gunichar2 const **digitLowerTable,
7079                                             gunichar2 const **digitUpperTable,
7080                                             gint64 const **tenPowersList,
7081                                             gint32 const **decHexDigits)
7082 {
7083         *mantissas = Formatter_MantissaBitsTable;
7084         *exponents = Formatter_TensExponentTable;
7085         *digitLowerTable = Formatter_DigitLowerTable;
7086         *digitUpperTable = Formatter_DigitUpperTable;
7087         *tenPowersList = Formatter_TenPowersList;
7088         *decHexDigits = Formatter_DecHexDigits;
7089 }
7090
7091 /* These parameters are "readonly" in corlib/System/Char.cs */
7092 static void
7093 ves_icall_System_Char_GetDataTablePointers (guint8 const **category_data,
7094                                             guint8 const **numeric_data,
7095                                             gdouble const **numeric_data_values,
7096                                             guint16 const **to_lower_data_low,
7097                                             guint16 const **to_lower_data_high,
7098                                             guint16 const **to_upper_data_low,
7099                                             guint16 const **to_upper_data_high)
7100 {
7101         *category_data = CategoryData;
7102         *numeric_data = NumericData;
7103         *numeric_data_values = NumericDataValues;
7104         *to_lower_data_low = ToLowerDataLow;
7105         *to_lower_data_high = ToLowerDataHigh;
7106         *to_upper_data_low = ToUpperDataLow;
7107         *to_upper_data_high = ToUpperDataHigh;
7108 }
7109
7110 static gint32
7111 ves_icall_MonoDebugger_GetMethodToken (MonoReflectionMethod *method)
7112 {
7113         return method->method->token;
7114 }
7115
7116 /*
7117  * We return NULL for no modifiers so the corlib code can return Type.EmptyTypes
7118  * and avoid useless allocations.
7119  */
7120 static MonoArray*
7121 type_array_from_modifiers (MonoImage *image, MonoType *type, int optional)
7122 {
7123         MonoArray *res;
7124         int i, count = 0;
7125         for (i = 0; i < type->num_mods; ++i) {
7126                 if ((optional && !type->modifiers [i].required) || (!optional && type->modifiers [i].required))
7127                         count++;
7128         }
7129         if (!count)
7130                 return NULL;
7131         res = mono_array_new (mono_domain_get (), mono_defaults.systemtype_class, count);
7132         count = 0;
7133         for (i = 0; i < type->num_mods; ++i) {
7134                 if ((optional && !type->modifiers [i].required) || (!optional && type->modifiers [i].required)) {
7135                         MonoClass *klass = mono_class_get (image, type->modifiers [i].token);
7136                         mono_array_setref (res, count, mono_type_get_object (mono_domain_get (), &klass->byval_arg));
7137                         count++;
7138                 }
7139         }
7140         return res;
7141 }
7142
7143 static MonoArray*
7144 param_info_get_type_modifiers (MonoReflectionParameter *param, MonoBoolean optional)
7145 {
7146         MonoType *type = param->ClassImpl->type;
7147         MonoClass *member_class = mono_object_class (param->MemberImpl);
7148         MonoMethod *method = NULL;
7149         MonoImage *image;
7150         int pos;
7151         MonoMethodSignature *sig;
7152
7153         if (mono_class_is_reflection_method_or_constructor (member_class)) {
7154                 MonoReflectionMethod *rmethod = (MonoReflectionMethod*)param->MemberImpl;
7155                 method = rmethod->method;
7156         } else if (member_class->image == mono_defaults.corlib && !strcmp ("MonoProperty", member_class->name)) {
7157                 MonoReflectionProperty *prop = (MonoReflectionProperty *)param->MemberImpl;
7158                 if (!(method = prop->property->get))
7159                         method = prop->property->set;
7160                 g_assert (method);
7161         } else {
7162                 char *type_name = mono_type_get_full_name (member_class);
7163                 char *msg = g_strdup_printf ("Custom modifiers on a ParamInfo with member %s are not supported", type_name);
7164                 MonoException *ex = mono_get_exception_not_supported  (msg);
7165                 g_free (type_name);
7166                 g_free (msg);
7167                 mono_raise_exception (ex);
7168         }
7169
7170         image = method->klass->image;
7171         pos = param->PositionImpl;
7172         sig = mono_method_signature (method);
7173         if (pos == -1)
7174                 type = sig->ret;
7175         else
7176                 type = sig->params [pos];
7177
7178         return type_array_from_modifiers (image, type, optional);
7179 }
7180
7181 static MonoType*
7182 get_property_type (MonoProperty *prop)
7183 {
7184         MonoMethodSignature *sig;
7185         if (prop->get) {
7186                 sig = mono_method_signature (prop->get);
7187                 return sig->ret;
7188         } else if (prop->set) {
7189                 sig = mono_method_signature (prop->set);
7190                 return sig->params [sig->param_count - 1];
7191         }
7192         return NULL;
7193 }
7194
7195 static MonoArray*
7196 property_info_get_type_modifiers (MonoReflectionProperty *property, MonoBoolean optional)
7197 {
7198         MonoType *type = get_property_type (property->property);
7199         MonoImage *image = property->klass->image;
7200
7201         if (!type)
7202                 return NULL;
7203         return type_array_from_modifiers (image, type, optional);
7204 }
7205
7206 /*
7207  *Construct a MonoType suited to be used to decode a constant blob object.
7208  *
7209  * @type is the target type which will be constructed
7210  * @blob_type is the blob type, for example, that comes from the constant table
7211  * @real_type is the expected constructed type.
7212  */
7213 static void
7214 mono_type_from_blob_type (MonoType *type, MonoTypeEnum blob_type, MonoType *real_type)
7215 {
7216         type->type = blob_type;
7217         type->data.klass = NULL;
7218         if (blob_type == MONO_TYPE_CLASS)
7219                 type->data.klass = mono_defaults.object_class;
7220         else if (real_type->type == MONO_TYPE_VALUETYPE && real_type->data.klass->enumtype) {
7221                 /* For enums, we need to use the base type */
7222                 type->type = MONO_TYPE_VALUETYPE;
7223                 type->data.klass = mono_class_from_mono_type (real_type);
7224         } else
7225                 type->data.klass = mono_class_from_mono_type (real_type);
7226 }
7227
7228 static MonoObject*
7229 property_info_get_default_value (MonoReflectionProperty *property)
7230 {
7231         MonoType blob_type;
7232         MonoProperty *prop = property->property;
7233         MonoType *type = get_property_type (prop);
7234         MonoDomain *domain = mono_object_domain (property);
7235         MonoTypeEnum def_type;
7236         const char *def_value;
7237         MonoObject *o;
7238
7239         g_assert (!prop->parent->image->dynamic);
7240
7241         mono_class_init (prop->parent);
7242
7243         if (!(prop->attrs & PROPERTY_ATTRIBUTE_HAS_DEFAULT))
7244                 mono_raise_exception (mono_get_exception_invalid_operation (NULL));
7245
7246         def_value = mono_class_get_property_default_value (prop, &def_type);
7247
7248         mono_type_from_blob_type (&blob_type, def_type, type);
7249         o = mono_get_object_from_blob (domain, &blob_type, def_value);
7250
7251         return o;
7252 }
7253
7254 static MonoBoolean
7255 custom_attrs_defined_internal (MonoObject *obj, MonoReflectionType *attr_type)
7256 {
7257         MonoCustomAttrInfo *cinfo;
7258         gboolean found;
7259
7260         cinfo = mono_reflection_get_custom_attrs_info (obj);
7261         if (!cinfo)
7262                 return FALSE;
7263         found = mono_custom_attrs_has_attr (cinfo, mono_class_from_mono_type (attr_type->type));
7264         if (!cinfo->cached)
7265                 mono_custom_attrs_free (cinfo);
7266         return found;
7267 }
7268
7269 static MonoArray*
7270 custom_attrs_get_by_type (MonoObject *obj, MonoReflectionType *attr_type)
7271 {
7272         MonoArray *res = mono_reflection_get_custom_attrs_by_type (obj, attr_type ? mono_class_from_mono_type (attr_type->type) : NULL);
7273
7274         if (mono_loader_get_last_error ()) {
7275                 mono_raise_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ()));
7276                 g_assert_not_reached ();
7277                 /* Not reached */
7278                 return NULL;
7279         } else {
7280                 return res;
7281         }
7282 }
7283
7284 static MonoString*
7285 ves_icall_Mono_Runtime_GetDisplayName (void)
7286 {
7287         char *info;
7288         MonoString *display_name;
7289
7290         info = mono_get_runtime_callbacks ()->get_runtime_build_info ();
7291         display_name = mono_string_new (mono_domain_get (), info);
7292         g_free (info);
7293         return display_name;
7294 }
7295
7296 static MonoString*
7297 ves_icall_System_ComponentModel_Win32Exception_W32ErrorMessage (guint32 code)
7298 {
7299         MonoString *message;
7300         guint32 ret;
7301         gunichar2 buf[256];
7302
7303         ret = FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM |
7304                              FORMAT_MESSAGE_IGNORE_INSERTS, NULL, code, 0,
7305                              buf, 255, NULL);
7306         if (ret == 0) {
7307                 message = mono_string_new (mono_domain_get (), "Error looking up error string");
7308         } else {
7309                 message = mono_string_new_utf16 (mono_domain_get (), buf, ret);
7310         }
7311
7312         return message;
7313 }
7314
7315 const static guchar
7316 dbase64 [] = {
7317         128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
7318         128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
7319         128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 62, 128, 128, 128, 63,
7320         52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 128, 128, 128, 0, 128, 128,
7321         128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
7322         15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 128, 128, 128, 128, 128,
7323         128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
7324         41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51
7325 };
7326
7327 static MonoArray *
7328 base64_to_byte_array (gunichar2 *start, gint ilength, MonoBoolean allowWhitespaceOnly)
7329 {
7330         gint ignored;
7331         gint i;
7332         gunichar2 c;
7333         gunichar2 last, prev_last, prev2_last;
7334         gint olength;
7335         MonoArray *result;
7336         guchar *res_ptr;
7337         gint a [4], b [4];
7338         MonoException *exc;
7339
7340         ignored = 0;
7341         last = prev_last = 0, prev2_last = 0;
7342         for (i = 0; i < ilength; i++) {
7343                 c = start [i];
7344                 if (c >= sizeof (dbase64)) {
7345                         exc = mono_exception_from_name_msg (mono_get_corlib (),
7346                                 "System", "FormatException",
7347                                 "Invalid character found.");
7348                         mono_raise_exception (exc);
7349                 } else if (isspace (c)) {
7350                         ignored++;
7351                 } else {
7352                         prev2_last = prev_last;
7353                         prev_last = last;
7354                         last = c;
7355                 }
7356         }
7357
7358         olength = ilength - ignored;
7359
7360         if (allowWhitespaceOnly && olength == 0) {
7361                 return mono_array_new (mono_domain_get (), mono_defaults.byte_class, 0);
7362         }
7363
7364         if ((olength & 3) != 0 || olength <= 0) {
7365                 exc = mono_exception_from_name_msg (mono_get_corlib (), "System",
7366                                         "FormatException", "Invalid length.");
7367                 mono_raise_exception (exc);
7368         }
7369
7370         if (prev2_last == '=') {
7371                 exc = mono_exception_from_name_msg (mono_get_corlib (), "System", "FormatException", "Invalid format.");
7372                 mono_raise_exception (exc);
7373         }
7374
7375         olength = (olength * 3) / 4;
7376         if (last == '=')
7377                 olength--;
7378
7379         if (prev_last == '=')
7380                 olength--;
7381
7382         result = mono_array_new (mono_domain_get (), mono_defaults.byte_class, olength);
7383         res_ptr = mono_array_addr (result, guchar, 0);
7384         for (i = 0; i < ilength; ) {
7385                 int k;
7386
7387                 for (k = 0; k < 4 && i < ilength;) {
7388                         c = start [i++];
7389                         if (isspace (c))
7390                                 continue;
7391
7392                         a [k] = (guchar) c;
7393                         if (((b [k] = dbase64 [c]) & 0x80) != 0) {
7394                                 exc = mono_exception_from_name_msg (mono_get_corlib (),
7395                                         "System", "FormatException",
7396                                         "Invalid character found.");
7397                                 mono_raise_exception (exc);
7398                         }
7399                         k++;
7400                 }
7401
7402                 *res_ptr++ = (b [0] << 2) | (b [1] >> 4);
7403                 if (a [2] != '=')
7404                         *res_ptr++ = (b [1] << 4) | (b [2] >> 2);
7405                 if (a [3] != '=')
7406                         *res_ptr++ = (b [2] << 6) | b [3];
7407
7408                 while (i < ilength && isspace (start [i]))
7409                         i++;
7410         }
7411
7412         return result;
7413 }
7414
7415 static MonoArray *
7416 InternalFromBase64String (MonoString *str, MonoBoolean allowWhitespaceOnly)
7417 {
7418         MONO_ARCH_SAVE_REGS;
7419
7420         return base64_to_byte_array (mono_string_chars (str),
7421                 mono_string_length (str), allowWhitespaceOnly);
7422 }
7423
7424 static MonoArray *
7425 InternalFromBase64CharArray (MonoArray *input, gint offset, gint length)
7426 {
7427         MONO_ARCH_SAVE_REGS;
7428
7429         return base64_to_byte_array (mono_array_addr (input, gunichar2, offset),
7430                 length, FALSE);
7431 }
7432
7433 #define ICALL_TYPE(id,name,first)
7434 #define ICALL(id,name,func) Icall_ ## id,
7435
7436 enum {
7437 #include "metadata/icall-def.h"
7438         Icall_last
7439 };
7440
7441 #undef ICALL_TYPE
7442 #undef ICALL
7443 #define ICALL_TYPE(id,name,first) Icall_type_ ## id,
7444 #define ICALL(id,name,func)
7445 enum {
7446 #include "metadata/icall-def.h"
7447         Icall_type_num
7448 };
7449
7450 #undef ICALL_TYPE
7451 #undef ICALL
7452 #define ICALL_TYPE(id,name,firstic) {(Icall_ ## firstic)},
7453 #define ICALL(id,name,func)
7454 typedef struct {
7455         guint16 first_icall;
7456 } IcallTypeDesc;
7457
7458 static const IcallTypeDesc
7459 icall_type_descs [] = {
7460 #include "metadata/icall-def.h"
7461         {Icall_last}
7462 };
7463
7464 #define icall_desc_num_icalls(desc) ((desc) [1].first_icall - (desc) [0].first_icall)
7465
7466 #undef ICALL_TYPE
7467 #define ICALL_TYPE(id,name,first)
7468 #undef ICALL
7469
7470 #ifdef HAVE_ARRAY_ELEM_INIT
7471 #define MSGSTRFIELD(line) MSGSTRFIELD1(line)
7472 #define MSGSTRFIELD1(line) str##line
7473
7474 static const struct msgstrtn_t {
7475 #define ICALL(id,name,func)
7476 #undef ICALL_TYPE
7477 #define ICALL_TYPE(id,name,first) char MSGSTRFIELD(__LINE__) [sizeof (name)];
7478 #include "metadata/icall-def.h"
7479 #undef ICALL_TYPE
7480 } icall_type_names_str = {
7481 #define ICALL_TYPE(id,name,first) (name),
7482 #include "metadata/icall-def.h"
7483 #undef ICALL_TYPE
7484 };
7485 static const guint16 icall_type_names_idx [] = {
7486 #define ICALL_TYPE(id,name,first) [Icall_type_ ## id] = offsetof (struct msgstrtn_t, MSGSTRFIELD(__LINE__)),
7487 #include "metadata/icall-def.h"
7488 #undef ICALL_TYPE
7489 };
7490 #define icall_type_name_get(id) ((const char*)&icall_type_names_str + icall_type_names_idx [(id)])
7491
7492 static const struct msgstr_t {
7493 #undef ICALL
7494 #define ICALL_TYPE(id,name,first)
7495 #define ICALL(id,name,func) char MSGSTRFIELD(__LINE__) [sizeof (name)];
7496 #include "metadata/icall-def.h"
7497 #undef ICALL
7498 } icall_names_str = {
7499 #define ICALL(id,name,func) (name),
7500 #include "metadata/icall-def.h"
7501 #undef ICALL
7502 };
7503 static const guint16 icall_names_idx [] = {
7504 #define ICALL(id,name,func) [Icall_ ## id] = offsetof (struct msgstr_t, MSGSTRFIELD(__LINE__)),
7505 #include "metadata/icall-def.h"
7506 #undef ICALL
7507 };
7508 #define icall_name_get(id) ((const char*)&icall_names_str + icall_names_idx [(id)])
7509
7510 #else
7511
7512 #undef ICALL_TYPE
7513 #undef ICALL
7514 #define ICALL_TYPE(id,name,first) name,
7515 #define ICALL(id,name,func)
7516 static const char* const
7517 icall_type_names [] = {
7518 #include "metadata/icall-def.h"
7519         NULL
7520 };
7521
7522 #define icall_type_name_get(id) (icall_type_names [(id)])
7523
7524 #undef ICALL_TYPE
7525 #undef ICALL
7526 #define ICALL_TYPE(id,name,first)
7527 #define ICALL(id,name,func) name,
7528 static const char* const
7529 icall_names [] = {
7530 #include "metadata/icall-def.h"
7531         NULL
7532 };
7533 #define icall_name_get(id) icall_names [(id)]
7534
7535 #endif /* !HAVE_ARRAY_ELEM_INIT */
7536
7537 #undef ICALL_TYPE
7538 #undef ICALL
7539 #define ICALL_TYPE(id,name,first)
7540 #define ICALL(id,name,func) func,
7541 static const gconstpointer
7542 icall_functions [] = {
7543 #include "metadata/icall-def.h"
7544         NULL
7545 };
7546
7547 static GHashTable *icall_hash = NULL;
7548 static GHashTable *jit_icall_hash_name = NULL;
7549 static GHashTable *jit_icall_hash_addr = NULL;
7550
7551 void
7552 mono_icall_init (void)
7553 {
7554         int i = 0;
7555
7556         /* check that tables are sorted: disable in release */
7557         if (TRUE) {
7558                 int j;
7559                 const char *prev_class = NULL;
7560                 const char *prev_method;
7561
7562                 for (i = 0; i < Icall_type_num; ++i) {
7563                         const IcallTypeDesc *desc;
7564                         int num_icalls;
7565                         prev_method = NULL;
7566                         if (prev_class && strcmp (prev_class, icall_type_name_get (i)) >= 0)
7567                                 g_print ("class %s should come before class %s\n", icall_type_name_get (i), prev_class);
7568                         prev_class = icall_type_name_get (i);
7569                         desc = &icall_type_descs [i];
7570                         num_icalls = icall_desc_num_icalls (desc);
7571                         /*g_print ("class %s has %d icalls starting at %d\n", prev_class, num_icalls, desc->first_icall);*/
7572                         for (j = 0; j < num_icalls; ++j) {
7573                                 const char *methodn = icall_name_get (desc->first_icall + j);
7574                                 if (prev_method && strcmp (prev_method, methodn) >= 0)
7575                                         g_print ("method %s should come before method %s\n", methodn, prev_method);
7576                                 prev_method = methodn;
7577                         }
7578                 }
7579         }
7580
7581         icall_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
7582 }
7583
7584 void
7585 mono_icall_cleanup (void)
7586 {
7587         g_hash_table_destroy (icall_hash);
7588         g_hash_table_destroy (jit_icall_hash_name);
7589         g_hash_table_destroy (jit_icall_hash_addr);
7590 }
7591
7592 void
7593 mono_add_internal_call (const char *name, gconstpointer method)
7594 {
7595         mono_loader_lock ();
7596
7597         g_hash_table_insert (icall_hash, g_strdup (name), (gpointer) method);
7598
7599         mono_loader_unlock ();
7600 }
7601
7602 #ifdef HAVE_ARRAY_ELEM_INIT
7603 static int
7604 compare_method_imap (const void *key, const void *elem)
7605 {
7606         const char* method_name = (const char*)&icall_names_str + (*(guint16*)elem);
7607         return strcmp (key, method_name);
7608 }
7609
7610 static gpointer
7611 find_method_icall (const IcallTypeDesc *imap, const char *name)
7612 {
7613         const guint16 *nameslot = bsearch (name, icall_names_idx + imap->first_icall, icall_desc_num_icalls (imap), sizeof (icall_names_idx [0]), compare_method_imap);
7614         if (!nameslot)
7615                 return NULL;
7616         return (gpointer)icall_functions [(nameslot - &icall_names_idx [0])];
7617 }
7618
7619 static int
7620 compare_class_imap (const void *key, const void *elem)
7621 {
7622         const char* class_name = (const char*)&icall_type_names_str + (*(guint16*)elem);
7623         return strcmp (key, class_name);
7624 }
7625
7626 static const IcallTypeDesc*
7627 find_class_icalls (const char *name)
7628 {
7629         const guint16 *nameslot = bsearch (name, icall_type_names_idx, Icall_type_num, sizeof (icall_type_names_idx [0]), compare_class_imap);
7630         if (!nameslot)
7631                 return NULL;
7632         return &icall_type_descs [nameslot - &icall_type_names_idx [0]];
7633 }
7634
7635 #else
7636 static int
7637 compare_method_imap (const void *key, const void *elem)
7638 {
7639         const char** method_name = (const char**)elem;
7640         return strcmp (key, *method_name);
7641 }
7642
7643 static gpointer
7644 find_method_icall (const IcallTypeDesc *imap, const char *name)
7645 {
7646         const char **nameslot = bsearch (name, icall_names + imap->first_icall, icall_desc_num_icalls (imap), sizeof (icall_names [0]), compare_method_imap);
7647         if (!nameslot)
7648                 return NULL;
7649         return (gpointer)icall_functions [(nameslot - icall_names)];
7650 }
7651
7652 static int
7653 compare_class_imap (const void *key, const void *elem)
7654 {
7655         const char** class_name = (const char**)elem;
7656         return strcmp (key, *class_name);
7657 }
7658
7659 static const IcallTypeDesc*
7660 find_class_icalls (const char *name)
7661 {
7662         const char **nameslot = bsearch (name, icall_type_names, Icall_type_num, sizeof (icall_type_names [0]), compare_class_imap);
7663         if (!nameslot)
7664                 return NULL;
7665         return &icall_type_descs [nameslot - icall_type_names];
7666 }
7667
7668 #endif
7669
7670 /*
7671  * we should probably export this as an helper (handle nested types).
7672  * Returns the number of chars written in buf.
7673  */
7674 static int
7675 concat_class_name (char *buf, int bufsize, MonoClass *klass)
7676 {
7677         int nspacelen, cnamelen;
7678         nspacelen = strlen (klass->name_space);
7679         cnamelen = strlen (klass->name);
7680         if (nspacelen + cnamelen + 2 > bufsize)
7681                 return 0;
7682         if (nspacelen) {
7683                 memcpy (buf, klass->name_space, nspacelen);
7684                 buf [nspacelen ++] = '.';
7685         }
7686         memcpy (buf + nspacelen, klass->name, cnamelen);
7687         buf [nspacelen + cnamelen] = 0;
7688         return nspacelen + cnamelen;
7689 }
7690
7691 gpointer
7692 mono_lookup_internal_call (MonoMethod *method)
7693 {
7694         char *sigstart;
7695         char *tmpsig;
7696         char mname [2048];
7697         int typelen = 0, mlen, siglen;
7698         gpointer res;
7699         const IcallTypeDesc *imap;
7700
7701         g_assert (method != NULL);
7702
7703         if (method->is_inflated)
7704                 method = ((MonoMethodInflated *) method)->declaring;
7705
7706         if (method->klass->nested_in) {
7707                 int pos = concat_class_name (mname, sizeof (mname)-2, method->klass->nested_in);
7708                 if (!pos)
7709                         return NULL;
7710
7711                 mname [pos++] = '/';
7712                 mname [pos] = 0;
7713
7714                 typelen = concat_class_name (mname+pos, sizeof (mname)-pos-1, method->klass);
7715                 if (!typelen)
7716                         return NULL;
7717
7718                 typelen += pos;
7719         } else {
7720                 typelen = concat_class_name (mname, sizeof (mname), method->klass);
7721                 if (!typelen)
7722                         return NULL;
7723         }
7724
7725         imap = find_class_icalls (mname);
7726
7727         mname [typelen] = ':';
7728         mname [typelen + 1] = ':';
7729
7730         mlen = strlen (method->name);
7731         memcpy (mname + typelen + 2, method->name, mlen);
7732         sigstart = mname + typelen + 2 + mlen;
7733         *sigstart = 0;
7734
7735         tmpsig = mono_signature_get_desc (mono_method_signature (method), TRUE);
7736         siglen = strlen (tmpsig);
7737         if (typelen + mlen + siglen + 6 > sizeof (mname))
7738                 return NULL;
7739         sigstart [0] = '(';
7740         memcpy (sigstart + 1, tmpsig, siglen);
7741         sigstart [siglen + 1] = ')';
7742         sigstart [siglen + 2] = 0;
7743         g_free (tmpsig);
7744
7745         mono_loader_lock ();
7746
7747         res = g_hash_table_lookup (icall_hash, mname);
7748         if (res) {
7749                 mono_loader_unlock ();
7750                 return res;
7751         }
7752         /* try without signature */
7753         *sigstart = 0;
7754         res = g_hash_table_lookup (icall_hash, mname);
7755         if (res) {
7756                 mono_loader_unlock ();
7757                 return res;
7758         }
7759
7760         /* it wasn't found in the static call tables */
7761         if (!imap) {
7762                 mono_loader_unlock ();
7763                 return NULL;
7764         }
7765         res = find_method_icall (imap, sigstart - mlen);
7766         if (res) {
7767                 mono_loader_unlock ();
7768                 return res;
7769         }
7770         /* try _with_ signature */
7771         *sigstart = '(';
7772         res = find_method_icall (imap, sigstart - mlen);
7773         if (res) {
7774                 mono_loader_unlock ();
7775                 return res;
7776         }
7777
7778         g_warning ("cant resolve internal call to \"%s\" (tested without signature also)", mname);
7779         g_print ("\nYour mono runtime and class libraries are out of sync.\n");
7780         g_print ("The out of sync library is: %s\n", method->klass->image->name);
7781         g_print ("\nWhen you update one from svn you need to update, compile and install\nthe other too.\n");
7782         g_print ("Do not report this as a bug unless you're sure you have updated correctly:\nyou probably have a broken mono install.\n");
7783         g_print ("If you see other errors or faults after this message they are probably related\n");
7784         g_print ("and you need to fix your mono install first.\n");
7785
7786         mono_loader_unlock ();
7787
7788         return NULL;
7789 }
7790
7791 static MonoType*
7792 type_from_typename (char *typename)
7793 {
7794         MonoClass *klass = NULL;        /* assignment to shut GCC warning up */
7795
7796         if (!strcmp (typename, "int"))
7797                 klass = mono_defaults.int_class;
7798         else if (!strcmp (typename, "ptr"))
7799                 klass = mono_defaults.int_class;
7800         else if (!strcmp (typename, "void"))
7801                 klass = mono_defaults.void_class;
7802         else if (!strcmp (typename, "int32"))
7803                 klass = mono_defaults.int32_class;
7804         else if (!strcmp (typename, "uint32"))
7805                 klass = mono_defaults.uint32_class;
7806         else if (!strcmp (typename, "int8"))
7807                 klass = mono_defaults.sbyte_class;
7808         else if (!strcmp (typename, "uint8"))
7809                 klass = mono_defaults.byte_class;
7810         else if (!strcmp (typename, "int16"))
7811                 klass = mono_defaults.int16_class;
7812         else if (!strcmp (typename, "uint16"))
7813                 klass = mono_defaults.uint16_class;
7814         else if (!strcmp (typename, "long"))
7815                 klass = mono_defaults.int64_class;
7816         else if (!strcmp (typename, "ulong"))
7817                 klass = mono_defaults.uint64_class;
7818         else if (!strcmp (typename, "float"))
7819                 klass = mono_defaults.single_class;
7820         else if (!strcmp (typename, "double"))
7821                 klass = mono_defaults.double_class;
7822         else if (!strcmp (typename, "object"))
7823                 klass = mono_defaults.object_class;
7824         else if (!strcmp (typename, "obj"))
7825                 klass = mono_defaults.object_class;
7826         else if (!strcmp (typename, "string"))
7827                 klass = mono_defaults.string_class;
7828         else if (!strcmp (typename, "bool"))
7829                 klass = mono_defaults.boolean_class;
7830         else if (!strcmp (typename, "boolean"))
7831                 klass = mono_defaults.boolean_class;
7832         else {
7833                 g_error ("%s", typename);
7834                 g_assert_not_reached ();
7835         }
7836         return &klass->byval_arg;
7837 }
7838
7839 MonoMethodSignature*
7840 mono_create_icall_signature (const char *sigstr)
7841 {
7842         gchar **parts;
7843         int i, len;
7844         gchar **tmp;
7845         MonoMethodSignature *res;
7846
7847         mono_loader_lock ();
7848         res = g_hash_table_lookup (mono_defaults.corlib->helper_signatures, sigstr);
7849         if (res) {
7850                 mono_loader_unlock ();
7851                 return res;
7852         }
7853
7854         parts = g_strsplit (sigstr, " ", 256);
7855
7856         tmp = parts;
7857         len = 0;
7858         while (*tmp) {
7859                 len ++;
7860                 tmp ++;
7861         }
7862
7863         res = mono_metadata_signature_alloc (mono_defaults.corlib, len - 1);
7864         res->pinvoke = 1;
7865
7866 #ifdef HOST_WIN32
7867         /*
7868          * Under windows, the default pinvoke calling convention is STDCALL but
7869          * we need CDECL.
7870          */
7871         res->call_convention = MONO_CALL_C;
7872 #endif
7873
7874         res->ret = type_from_typename (parts [0]);
7875         for (i = 1; i < len; ++i) {
7876                 res->params [i - 1] = type_from_typename (parts [i]);
7877         }
7878
7879         g_strfreev (parts);
7880
7881         g_hash_table_insert (mono_defaults.corlib->helper_signatures, (gpointer)sigstr, res);
7882
7883         mono_loader_unlock ();
7884
7885         return res;
7886 }
7887
7888 MonoJitICallInfo *
7889 mono_find_jit_icall_by_name (const char *name)
7890 {
7891         MonoJitICallInfo *info;
7892         g_assert (jit_icall_hash_name);
7893
7894         mono_loader_lock ();
7895         info = g_hash_table_lookup (jit_icall_hash_name, name);
7896         mono_loader_unlock ();
7897         return info;
7898 }
7899
7900 MonoJitICallInfo *
7901 mono_find_jit_icall_by_addr (gconstpointer addr)
7902 {
7903         MonoJitICallInfo *info;
7904         g_assert (jit_icall_hash_addr);
7905
7906         mono_loader_lock ();
7907         info = g_hash_table_lookup (jit_icall_hash_addr, (gpointer)addr);
7908         mono_loader_unlock ();
7909
7910         return info;
7911 }
7912
7913 /*
7914  * mono_get_jit_icall_info:
7915  *
7916  *   Return the hashtable mapping JIT icall names to MonoJitICallInfo structures. The
7917  * caller should access it while holding the loader lock.
7918  */
7919 GHashTable*
7920 mono_get_jit_icall_info (void)
7921 {
7922         return jit_icall_hash_name;
7923 }
7924
7925 void
7926 mono_register_jit_icall_wrapper (MonoJitICallInfo *info, gconstpointer wrapper)
7927 {
7928         mono_loader_lock ();
7929         g_hash_table_insert (jit_icall_hash_addr, (gpointer)wrapper, info);
7930         mono_loader_unlock ();
7931 }
7932
7933 MonoJitICallInfo *
7934 mono_register_jit_icall (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save)
7935 {
7936         MonoJitICallInfo *info;
7937
7938         g_assert (func);
7939         g_assert (name);
7940
7941         mono_loader_lock ();
7942
7943         if (!jit_icall_hash_name) {
7944                 jit_icall_hash_name = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, g_free);
7945                 jit_icall_hash_addr = g_hash_table_new (NULL, NULL);
7946         }
7947
7948         if (g_hash_table_lookup (jit_icall_hash_name, name)) {
7949                 g_warning ("jit icall already defined \"%s\"\n", name);
7950                 g_assert_not_reached ();
7951         }
7952
7953         info = g_new0 (MonoJitICallInfo, 1);
7954
7955         info->name = name;
7956         info->func = func;
7957         info->sig = sig;
7958
7959         if (is_save) {
7960                 info->wrapper = func;
7961         } else {
7962                 info->wrapper = NULL;
7963         }
7964
7965         g_hash_table_insert (jit_icall_hash_name, (gpointer)info->name, info);
7966         g_hash_table_insert (jit_icall_hash_addr, (gpointer)func, info);
7967
7968         mono_loader_unlock ();
7969         return info;
7970 }