mono/mini/interpreter/transform.c

   1 /*
   2  * transform CIL into different opcodes for more
   3  * efficient interpretation
   4  *
   5  * Written by Bernie Solomon (bernard@ugsolutions.com)
   6  * Copyright (c) 2004.
   7  */
   8
   9 #include <string.h>
  10 #include <mono/metadata/appdomain.h>
  11 #include <mono/metadata/debug-helpers.h>
  12 #include <mono/metadata/exception.h>
  13 #include <mono/metadata/mono-endian.h>
  14 #include <mono/metadata/marshal.h>
  15 #include <mono/metadata/profiler-private.h>
  16 #include <mono/metadata/tabledefs.h>
  17
  18 #include <mono/mini/mini.h>
  19
  20 #include "mintops.h"
  21 #include "interp.h"
  22
  23 // TODO: export from marshal.c
  24 MonoDelegate* mono_ftnptr_to_delegate (MonoClass *klass, gpointer ftn);
  25
  26 #define DEBUG 0
  27
  28 typedef struct
  29 {
  30         MonoClass *klass;
  31         unsigned char type;
  32         unsigned char flags;
  33 } StackInfo;
  34
  35 typedef struct
  36 {
  37         MonoMethod *method;
  38         MonoMethodHeader *header;
  39         RuntimeMethod *rtm;
  40         const unsigned char *il_code;
  41         const unsigned char *ip;
  42         const unsigned char *last_ip;
  43         const unsigned char *in_start;
  44         int code_size;
  45         int *in_offsets;
  46         int *forward_refs;
  47         StackInfo **stack_state;
  48         int *stack_height;
  49         int *vt_stack_size;
  50         unsigned char *is_bb_start;
  51         unsigned short *new_code;
  52         unsigned short *new_code_end;
  53         unsigned short *new_ip;
  54         unsigned short *last_new_ip;
  55         unsigned int max_code_size;
  56         StackInfo *stack;
  57         StackInfo *sp;
  58         unsigned int max_stack_height;
  59         unsigned int vt_sp;
  60         unsigned int max_vt_sp;
  61         int n_data_items;
  62         int max_data_items;
  63         void **data_items;
  64         GHashTable *data_hash;
  65 } TransformData;
  66
  67 #define MINT_TYPE_I1 0
  68 #define MINT_TYPE_U1 1
  69 #define MINT_TYPE_I2 2
  70 #define MINT_TYPE_U2 3
  71 #define MINT_TYPE_I4 4
  72 #define MINT_TYPE_I8 5
  73 #define MINT_TYPE_R4 6
  74 #define MINT_TYPE_R8 7
  75 #define MINT_TYPE_O  8
  76 #define MINT_TYPE_P  9
  77 #define MINT_TYPE_VT 10
  78
  79 #define STACK_TYPE_I4 0
  80 #define STACK_TYPE_I8 1
  81 #define STACK_TYPE_R8 2
  82 #define STACK_TYPE_O  3
  83 #define STACK_TYPE_VT 4
  84 #define STACK_TYPE_MP 5
  85 #define STACK_TYPE_F  6
  86
  87 static const char *stack_type_string [] = { "I4", "I8", "R8", "O ", "VT", "MP", "F " };
  88
  89 #if SIZEOF_VOID_P == 8
  90 #define STACK_TYPE_I STACK_TYPE_I8
  91 #else
  92 #define STACK_TYPE_I STACK_TYPE_I4
  93 #endif
  94
  95 static int stack_type [] = {
  96         STACK_TYPE_I4, /*I1*/
  97         STACK_TYPE_I4, /*U1*/
  98         STACK_TYPE_I4, /*I2*/
  99         STACK_TYPE_I4, /*U2*/
 100         STACK_TYPE_I4, /*I4*/
 101         STACK_TYPE_I8, /*I8*/
 102         STACK_TYPE_R8, /*R4*/
 103         STACK_TYPE_R8, /*R8*/
 104         STACK_TYPE_O,  /*O*/
 105         STACK_TYPE_MP, /*P*/
 106         STACK_TYPE_VT
 107 };
 108
 109 static void
 110 grow_code (TransformData *td)
 111 {
 112         unsigned int old_ip_offset = td->new_ip - td->new_code;
 113         unsigned int old_last_ip_offset = td->last_new_ip - td->new_code;
 114         g_assert (old_ip_offset <= td->max_code_size);
 115         td->new_code = g_realloc (td->new_code, (td->max_code_size *= 2) * sizeof (td->new_code [0]));
 116         td->new_code_end = td->new_code + td->max_code_size;
 117         td->new_ip = td->new_code + old_ip_offset;
 118         td->last_new_ip = td->new_code + old_last_ip_offset;
 119 }
 120
 121 #define ENSURE_CODE(td, n) \
 122         do { \
 123                 if ((td)->new_ip + (n) > (td)->new_code_end) \
 124                         grow_code (td); \
 125         } while (0)
 126
 127 #define ADD_CODE(td, n) \
 128         do { \
 129                 if ((td)->new_ip == (td)->new_code_end) \
 130                         grow_code (td); \
 131                 *(td)->new_ip++ = (n); \
 132         } while (0)
 133
 134 #define CHECK_STACK(td, n) \
 135         do { \
 136                 int stack_size = (td)->sp - (td)->stack; \
 137                 if (stack_size < (n)) \
 138                         g_warning ("%s.%s: not enough values (%d < %d) on stack at %04x", \
 139                                 (td)->method->klass->name, (td)->method->name, \
 140                                 stack_size, n, (td)->ip - (td)->il_code); \
 141         } while (0)
 142
 143 #define ENSURE_I4(td, sp_off) \
 144         do { \
 145                 if ((td)->sp [-sp_off].type == STACK_TYPE_I8) \
 146                         ADD_CODE(td, sp_off == 1 ? MINT_CONV_I4_I8 : MINT_CONV_I4_I8_SP); \
 147         } while (0)
 148
 149 static void
 150 handle_branch(TransformData *td, int short_op, int long_op, int offset)
 151 {
 152         int shorten_branch = 0;
 153         int target = td->ip + offset - td->il_code;
 154         if (target < 0 || target >= td->code_size)
 155                 g_assert_not_reached ();
 156         if (offset > 0 && td->stack_height [target] < 0) {
 157                 td->stack_height [target] = td->sp - td->stack;
 158                 if (td->stack_height [target] > 0)
 159                         td->stack_state [target] = g_memdup (td->stack, td->stack_height [target] * sizeof (td->stack [0]));
 160                 td->vt_stack_size [target] = td->vt_sp;
 161         }
 162         if (offset < 0) {
 163                 offset = td->in_offsets [target] - (td->new_ip - td->new_code);
 164                 if (offset >= -32768) {
 165                         shorten_branch = 1;
 166                 }
 167         } else {
 168                 int prev = td->forward_refs [target];
 169                 td->forward_refs [td->ip - td->il_code] = prev;
 170                 td->forward_refs [target] = td->ip - td->il_code;
 171                 offset = 0;
 172                 if (td->header->code_size <= 25000) /* FIX to be precise somehow? */
 173                         shorten_branch = 1;
 174         }
 175         if (shorten_branch) {
 176                 ADD_CODE(td, short_op);
 177                 ADD_CODE(td, offset);
 178         } else {
 179                 ADD_CODE(td, long_op);
 180                 ADD_CODE(td, * (unsigned short *)(&offset));
 181                 ADD_CODE(td, * ((unsigned short *)&offset + 1));
 182         }
 183 }
 184
 185 static void
 186 one_arg_branch(TransformData *td, int mint_op, int offset)
 187 {
 188         int type = td->sp [-1].type == STACK_TYPE_O || td->sp [-1].type == STACK_TYPE_MP ? STACK_TYPE_I : td->sp [-1].type;
 189         int long_op = mint_op + type - STACK_TYPE_I4;
 190         int short_op = long_op + MINT_BRFALSE_I4_S - MINT_BRFALSE_I4;
 191         CHECK_STACK(td, 1);
 192         --td->sp;
 193         handle_branch (td, short_op, long_op, offset);
 194 }
 195
 196 static void
 197 two_arg_branch(TransformData *td, int mint_op, int offset)
 198 {
 199         int type1 = td->sp [-1].type == STACK_TYPE_O || td->sp [-1].type == STACK_TYPE_MP ? STACK_TYPE_I : td->sp [-1].type;
 200         int type2 = td->sp [-2].type == STACK_TYPE_O || td->sp [-2].type == STACK_TYPE_MP ? STACK_TYPE_I : td->sp [-2].type;
 201         int long_op = mint_op + type1 - STACK_TYPE_I4;
 202         int short_op = long_op + MINT_BEQ_I4_S - MINT_BEQ_I4;
 203         CHECK_STACK(td, 2);
 204         if (type1 == STACK_TYPE_I4 && type2 == STACK_TYPE_I8) {
 205                 ADD_CODE(td, MINT_CONV_I8_I4);
 206                 td->in_offsets [td->ip - td->il_code]++;
 207         } else if (type1 == STACK_TYPE_I8 && type2 == STACK_TYPE_I4) {
 208                 ADD_CODE(td, MINT_CONV_I8_I4_SP);
 209                 td->in_offsets [td->ip - td->il_code]++;
 210         } else if (type1 != type2) {
 211                 g_warning("%s.%s: branch type mismatch %d %d",
 212                         td->method->klass->name, td->method->name,
 213                         td->sp [-1].type, td->sp [-2].type);
 214         }
 215         td->sp -= 2;
 216         handle_branch (td, short_op, long_op, offset);
 217 }
 218
 219 static void
 220 unary_arith_op(TransformData *td, int mint_op)
 221 {
 222         int op = mint_op + td->sp [-1].type - STACK_TYPE_I4;
 223         CHECK_STACK(td, 1);
 224         ADD_CODE(td, op);
 225 }
 226
 227 static void
 228 binary_arith_op(TransformData *td, int mint_op)
 229 {
 230         int type1 = td->sp [-2].type;
 231         int type2 = td->sp [-1].type;
 232         int op;
 233 #if SIZEOF_VOID_P == 8
 234         if ((type1 == STACK_TYPE_MP || type1 == STACK_TYPE_I8) && type2 == STACK_TYPE_I4) {
 235                 ADD_CODE(td, MINT_CONV_I8_I4);
 236                 type2 = STACK_TYPE_I8;
 237         }
 238         if (type1 == STACK_TYPE_I4 && (type2 == STACK_TYPE_MP || type2 == STACK_TYPE_I8)) {
 239                 ADD_CODE(td, MINT_CONV_I8_I4_SP);
 240                 type1 = STACK_TYPE_I8;
 241                 td->sp [-2].type = STACK_TYPE_I8;
 242         }
 243 #endif
 244         if (type1 == STACK_TYPE_MP)
 245                 type1 = STACK_TYPE_I;
 246         if (type2 == STACK_TYPE_MP)
 247                 type2 = STACK_TYPE_I;
 248         if (type1 != type2) {
 249                 g_warning("%s.%s: %04x arith type mismatch %s %d %d",
 250                         td->method->klass->name, td->method->name,
 251                         td->ip - td->il_code, mono_interp_opname[mint_op], type1, type2);
 252         }
 253         op = mint_op + type1 - STACK_TYPE_I4;
 254         CHECK_STACK(td, 2);
 255         ADD_CODE(td, op);
 256         --td->sp;
 257 }
 258
 259 static void
 260 binary_int_op(TransformData *td, int mint_op)
 261 {
 262         int op = mint_op + td->sp [-1].type - STACK_TYPE_I4;
 263         CHECK_STACK(td, 2);
 264         if (td->sp [-1].type != td->sp [-2].type)
 265                 g_warning("%s.%s: int type mismatch", td->method->klass->name, td->method->name);
 266         ADD_CODE(td, op);
 267         --td->sp;
 268 }
 269
 270 static void
 271 shift_op(TransformData *td, int mint_op)
 272 {
 273         int op = mint_op + td->sp [-2].type - STACK_TYPE_I4;
 274         CHECK_STACK(td, 2);
 275         if (td->sp [-1].type != STACK_TYPE_I4) {
 276                 g_warning("%s.%s: shift type mismatch %d",
 277                         td->method->klass->name, td->method->name,
 278                         td->sp [-2].type);
 279         }
 280         ADD_CODE(td, op);
 281         --td->sp;
 282 }
 283
 284 static int
 285 mint_type(MonoType *type)
 286 {
 287         if (type->byref)
 288                 return MINT_TYPE_P;
 289 enum_type:
 290         switch (type->type) {
 291         case MONO_TYPE_I1:
 292                 return MINT_TYPE_I1;
 293         case MONO_TYPE_U1:
 294         case MONO_TYPE_BOOLEAN:
 295                 return MINT_TYPE_U1;
 296         case MONO_TYPE_I2:
 297                 return MINT_TYPE_I2;
 298         case MONO_TYPE_U2:
 299         case MONO_TYPE_CHAR:
 300                 return MINT_TYPE_U2;
 301         case MONO_TYPE_I4:
 302         case MONO_TYPE_U4:
 303                 return MINT_TYPE_I4;
 304         case MONO_TYPE_I:
 305         case MONO_TYPE_U:
 306 #if SIZEOF_VOID_P == 4
 307                 return MINT_TYPE_I4;
 308 #else
 309                 return MINT_TYPE_I8;
 310 #endif
 311         case MONO_TYPE_PTR:
 312                 return MINT_TYPE_P;
 313         case MONO_TYPE_R4:
 314                 return MINT_TYPE_R4;
 315         case MONO_TYPE_I8:
 316         case MONO_TYPE_U8:
 317                 return MINT_TYPE_I8;
 318         case MONO_TYPE_R8:
 319                 return MINT_TYPE_R8;
 320         case MONO_TYPE_STRING:
 321         case MONO_TYPE_SZARRAY:
 322         case MONO_TYPE_CLASS:
 323         case MONO_TYPE_OBJECT:
 324         case MONO_TYPE_ARRAY:
 325                 return MINT_TYPE_O;
 326         case MONO_TYPE_VALUETYPE:
 327                 if (type->data.klass->enumtype) {
 328                         type = mono_class_enum_basetype (type->data.klass);
 329                         goto enum_type;
 330                 } else
 331                         return MINT_TYPE_VT;
 332         case MONO_TYPE_GENERICINST:
 333                 type = &type->data.generic_class->container_class->byval_arg;
 334                 goto enum_type;
 335         default:
 336                 g_warning ("got type 0x%02x", type->type);
 337                 g_assert_not_reached ();
 338         }
 339         return -1;
 340 }
 341
 342 static int
 343 can_store (int stack_type, int var_type)
 344 {
 345         if (stack_type == STACK_TYPE_O || stack_type == STACK_TYPE_MP)
 346                 stack_type = STACK_TYPE_I;
 347         if (var_type == STACK_TYPE_O || var_type == STACK_TYPE_MP)
 348                 var_type = STACK_TYPE_I;
 349         return stack_type == var_type;
 350 }
 351
 352 #define SET_SIMPLE_TYPE(s, ty) \
 353         do { \
 354                 (s)->type = (ty); \
 355                 (s)->flags = 0; \
 356                 (s)->klass = NULL; \
 357         } while (0)
 358
 359 #define SET_TYPE(s, ty, k) \
 360         do { \
 361                 (s)->type = (ty); \
 362                 (s)->flags = 0; \
 363                 (s)->klass = k; \
 364         } while (0)
 365
 366 #define PUSH_SIMPLE_TYPE(td, ty) \
 367         do { \
 368                 int sp_height; \
 369                 (td)->sp++; \
 370                 sp_height = (td)->sp - (td)->stack; \
 371                 if (sp_height > (td)->max_stack_height) \
 372                         (td)->max_stack_height = sp_height; \
 373                 SET_SIMPLE_TYPE((td)->sp - 1, ty); \
 374         } while (0)
 375
 376 #define PUSH_TYPE(td, ty, k) \
 377         do { \
 378                 int sp_height; \
 379                 (td)->sp++; \
 380                 sp_height = (td)->sp - (td)->stack; \
 381                 if (sp_height > (td)->max_stack_height) \
 382                         (td)->max_stack_height = sp_height; \
 383                 SET_TYPE((td)->sp - 1, ty, k); \
 384         } while (0)
 385
 386 #define PUSH_VT(td, size) \
 387         do { \
 388                 (td)->vt_sp += ((size) + 7) & ~7; \
 389                 if ((td)->vt_sp > (td)->max_vt_sp) \
 390                         (td)->max_vt_sp = (td)->vt_sp; \
 391         } while (0)
 392
 393 #define POP_VT(td, size) \
 394         do { \
 395                 (td)->vt_sp -= ((size) + 7) & ~7; \
 396         } while (0)
 397
 398 #if NO_UNALIGNED_ACCESS
 399 #define WRITE32(td, v) \
 400         do { \
 401                 ENSURE_CODE(td, 2); \
 402                 * (guint16 *)((td)->new_ip) = * (guint16 *)(v); \
 403                 * ((guint16 *)((td)->new_ip) + 1) = * ((guint16 *)(v) + 1); \
 404                 (td)->new_ip += 2; \
 405         } while (0)
 406
 407 #define WRITE64(td, v) \
 408         do { \
 409                 ENSURE_CODE(td, 4); \
 410                 * (guint16 *)((td)->new_ip) = * (guint16 *)(v); \
 411                 * ((guint16 *)((td)->new_ip) + 1) = * ((guint16 *)(v) + 1); \
 412                 * ((guint16 *)((td)->new_ip) + 2) = * ((guint16 *)(v) + 2); \
 413                 * ((guint16 *)((td)->new_ip) + 3) = * ((guint16 *)(v) + 3); \
 414                 (td)->new_ip += 4; \
 415         } while (0)
 416 #else
 417 #define WRITE32(td, v) \
 418         do { \
 419                 ENSURE_CODE(td, 2); \
 420                 * (guint32 *)((td)->new_ip) = * (guint32 *)(v); \
 421                 (td)->new_ip += 2; \
 422         } while (0)
 423
 424 #define WRITE64(td, v) \
 425         do { \
 426                 ENSURE_CODE(td, 4); \
 427                 * (guint64 *)((td)->new_ip) = * (guint64 *)(v); \
 428                 (td)->new_ip += 4; \
 429         } while (0)
 430
 431 #endif
 432
 433 static void
 434 load_arg(TransformData *td, int n)
 435 {
 436         int mt;
 437         MonoClass *klass = NULL;
 438         if (n == 0 && mono_method_signature (td->method)->hasthis) {
 439                 if (td->method->klass->valuetype)
 440                         mt = MINT_TYPE_P;
 441                 else {
 442                         mt = MINT_TYPE_O;
 443                         klass = td->method->klass;
 444                 }
 445                 ADD_CODE(td, MINT_LDTHIS);
 446         } else {
 447                 MonoType *type;
 448                 n -= mono_method_signature (td->method)->hasthis;
 449                 type = mono_method_signature (td->method)->params [n];
 450                 mt = mint_type (type);
 451                 if (mt == MINT_TYPE_VT) {
 452                         gint32 size;
 453                         klass = mono_class_from_mono_type (type);
 454                         if (mono_method_signature (td->method)->pinvoke)
 455                                 size = mono_class_native_size (klass, NULL);
 456                         else
 457                                 size = mono_class_value_size (klass, NULL);
 458                         PUSH_VT(td, size);
 459                         ADD_CODE(td, MINT_LDARG_VT);
 460                         ADD_CODE(td, td->rtm->arg_offsets [n]); /* FIX for large offset */
 461                         WRITE32(td, &size);
 462                 } else {
 463                         ADD_CODE(td, MINT_LDARG_I1 + (mt - MINT_TYPE_I1));
 464                         ADD_CODE(td, td->rtm->arg_offsets [n]); /* FIX for large offset */
 465                         if (mt == MINT_TYPE_O)
 466                                 klass = mono_class_from_mono_type (type);
 467                 }
 468         }
 469         PUSH_TYPE(td, stack_type[mt], klass);
 470 }
 471
 472 static void
 473 store_arg(TransformData *td, int n)
 474 {
 475         int mt;
 476         CHECK_STACK (td, 1);
 477         if (n == 0 && mono_method_signature (td->method)->hasthis)
 478                 ADD_CODE(td, MINT_STTHIS);
 479         else {
 480                 MonoType *type;
 481                 n -= mono_method_signature (td->method)->hasthis;
 482                 type = mono_method_signature (td->method)->params [n];
 483                 mt = mint_type (type);
 484                 if (mt == MINT_TYPE_VT) {
 485                         gint32 size;
 486                         g_error ("data.klass");
 487                         if (mono_method_signature (td->method)->pinvoke)
 488                                 size = mono_class_native_size (type->data.klass, NULL);
 489                         else
 490                                 size = mono_class_value_size (type->data.klass, NULL);
 491                         ADD_CODE(td, MINT_STARG_VT);
 492                         ADD_CODE(td, n);
 493                         WRITE32(td, &size);
 494                         if (td->sp [-1].type == STACK_TYPE_VT)
 495                                 POP_VT(td, size);
 496                 } else {
 497                         ADD_CODE(td, MINT_STARG_I1 + (mt - MINT_TYPE_I1));
 498                         ADD_CODE(td, td->rtm->arg_offsets [n]);
 499                 }
 500         }
 501         --td->sp;
 502 }
 503
 504 static void
 505 store_inarg(TransformData *td, int n)
 506 {
 507         MonoClass *klass = mono_class_from_mono_type (mono_method_signature (td->method)->params [n]);
 508         int mt = mint_type (&klass->byval_arg);
 509         if (mt == MINT_TYPE_VT) {
 510                 gint32 size;
 511                 if (mono_method_signature (td->method)->pinvoke)
 512                         size = mono_class_native_size (klass, NULL);
 513                 else
 514                         size = mono_class_value_size (klass, NULL);
 515                 ADD_CODE(td, MINT_STINARG_VT);
 516                 ADD_CODE(td, n);
 517                 WRITE32(td, &size);
 518         } else {
 519                 ADD_CODE(td, MINT_STINARG_I1 + (mt - MINT_TYPE_I1));
 520                 ADD_CODE(td, n);
 521         }
 522 }
 523
 524 static void
 525 load_local(TransformData *td, int n)
 526 {
 527         MonoType *type = td->header->locals [n];
 528         int mt = mint_type (type);
 529         int offset = td->rtm->local_offsets [n];
 530         MonoClass *klass = NULL;
 531         if (mt == MINT_TYPE_VT) {
 532                 klass = mono_class_from_mono_type (type);
 533                 gint32 size = mono_class_value_size (klass, NULL);
 534                 PUSH_VT(td, size);
 535                 ADD_CODE(td, MINT_LDLOC_VT);
 536                 ADD_CODE(td, offset); /*FIX for large offset */
 537                 WRITE32(td, &size);
 538         } else {
 539                 g_assert (mt < MINT_TYPE_VT);
 540                 if (mt == MINT_TYPE_I4 && !td->is_bb_start [td->in_start - td->il_code] && td->last_new_ip != NULL &&
 541                         td->last_new_ip [0] == MINT_STLOC_I4 && td->last_new_ip [1] == offset) {
 542                         td->last_new_ip [0] = MINT_STLOC_NP_I4;
 543                 } else if (mt == MINT_TYPE_O && !td->is_bb_start [td->in_start - td->il_code] && td->last_new_ip != NULL &&
 544                         td->last_new_ip [0] == MINT_STLOC_O && td->last_new_ip [1] == offset) {
 545                         td->last_new_ip [0] = MINT_STLOC_NP_O;
 546                 } else {
 547                         ADD_CODE(td, MINT_LDLOC_I1 + (mt - MINT_TYPE_I1));
 548                         ADD_CODE(td, offset); /*FIX for large offset */
 549                 }
 550                 if (mt == MINT_TYPE_O)
 551                         klass = mono_class_from_mono_type (type);
 552         }
 553         PUSH_TYPE(td, stack_type[mt], klass);
 554 }
 555
 556 static void
 557 store_local(TransformData *td, int n)
 558 {
 559         MonoType *type = td->header->locals [n];
 560         int mt = mint_type (type);
 561         int offset = td->rtm->local_offsets [n];
 562         CHECK_STACK (td, 1);
 563 #if SIZEOF_VOID_P == 8
 564         if (td->sp [-1].type == STACK_TYPE_I4 && stack_type [mt] == STACK_TYPE_I8) {
 565                 ADD_CODE(td, MINT_CONV_I8_I4);
 566                 td->sp [-1].type = STACK_TYPE_I8;
 567         }
 568 #endif
 569         if (!can_store(td->sp [-1].type, stack_type [mt])) {
 570                 g_warning("%s.%s: Store local stack type mismatch %d %d",
 571                         td->method->klass->name, td->method->name,
 572                         stack_type [mt], td->sp [-1].type);
 573         }
 574         if (mt == MINT_TYPE_VT) {
 575                 MonoClass *klass = mono_class_from_mono_type (type);
 576                 gint32 size = mono_class_value_size (klass, NULL);
 577                 ADD_CODE(td, MINT_STLOC_VT);
 578                 ADD_CODE(td, offset); /*FIX for large offset */
 579                 WRITE32(td, &size);
 580                 if (td->sp [-1].type == STACK_TYPE_VT)
 581                         POP_VT(td, size);
 582         } else {
 583                 g_assert (mt < MINT_TYPE_VT);
 584                 ADD_CODE(td, MINT_STLOC_I1 + (mt - MINT_TYPE_I1));
 585                 ADD_CODE(td, offset); /*FIX for large offset */
 586         }
 587         --td->sp;
 588 }
 589
 590 #define SIMPLE_OP(td, op) \
 591         do { \
 592                 ADD_CODE(&td, op); \
 593                 ++td.ip; \
 594         } while (0)
 595
 596 static guint16
 597 get_data_item_index (TransformData *td, void *ptr)
 598 {
 599         gpointer p = g_hash_table_lookup (td->data_hash, ptr);
 600         guint index;
 601         if (p != NULL)
 602                 return GPOINTER_TO_UINT (p) - 1;
 603         if (td->max_data_items == td->n_data_items) {
 604                 td->max_data_items = td->n_data_items == 0 ? 16 : 2 * td->max_data_items;
 605                 td->data_items = g_realloc (td->data_items, td->max_data_items * sizeof(td->data_items [0]));
 606         }
 607         index = td->n_data_items;
 608         td->data_items [index] = ptr;
 609         ++td->n_data_items;
 610         g_hash_table_insert (td->data_hash, ptr, GUINT_TO_POINTER (index + 1));
 611         return index;
 612 }
 613
 614 static void
 615 interp_transform_call (TransformData *td, MonoMethod *method, MonoMethod *target_method, MonoDomain *domain, MonoGenericContext *generic_context, unsigned char *is_bb_start, int body_start_offset)
 616 {
 617         MonoImage *image = method->klass->image;
 618         MonoMethodSignature *csignature;
 619         MonoError error;
 620         int virtual = *td->ip == CEE_CALLVIRT;
 621         int calli = *td->ip == CEE_CALLI || *td->ip == CEE_MONO_CALLI_EXTRA_ARG;
 622         int i;
 623         guint32 vt_stack_used = 0;
 624         guint32 vt_res_size = 0;
 625         int op = -1;
 626         int native = 0;
 627         int is_void = 0;
 628
 629         guint32 token = read32 (td->ip + 1);
 630
 631         if (target_method == NULL) {
 632                 if (calli) {
 633                         CHECK_STACK(td, 1);
 634                         native = (method->wrapper_type != MONO_WRAPPER_DELEGATE_INVOKE && td->sp [-1].type == STACK_TYPE_I);
 635                         --td->sp;
 636                         if (method->wrapper_type != MONO_WRAPPER_NONE)
 637                                 csignature = (MonoMethodSignature *)mono_method_get_wrapper_data (method, token);
 638                         else
 639                                 csignature = mono_metadata_parse_signature (image, token);
 640                         target_method = NULL;
 641                 } else {
 642                         if (method->wrapper_type == MONO_WRAPPER_NONE)
 643                                 target_method = mono_get_method_full (image, token, NULL, generic_context);
 644                         else
 645                                 target_method = (MonoMethod *)mono_method_get_wrapper_data (method, token);
 646                         csignature = mono_method_signature (target_method);
 647                         if (target_method->klass == mono_defaults.string_class) {
 648                                 if (target_method->name [0] == 'g') {
 649                                         if (strcmp (target_method->name, "get_Chars") == 0)
 650                                                 op = MINT_GETCHR;
 651                                         else if (strcmp (target_method->name, "get_Length") == 0)
 652                                                 op = MINT_STRLEN;
 653                                 }
 654                         } else if (target_method->klass == mono_defaults.array_class) {
 655                                 if (strcmp (target_method->name, "get_Rank") == 0)
 656                                         op = MINT_ARRAY_RANK;
 657                                 else if (strcmp (target_method->name, "get_Length") == 0)
 658                                         op = MINT_LDLEN;
 659                         }
 660                 }
 661         } else {
 662                 csignature = mono_method_signature (target_method);
 663         }
 664
 665         CHECK_STACK (td, csignature->param_count + csignature->hasthis);
 666         if (!calli && (!virtual || (target_method->flags & METHOD_ATTRIBUTE_VIRTUAL) == 0) &&
 667                 (target_method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) == 0 &&
 668                 (target_method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) == 0) {
 669                 int called_inited = mono_class_vtable (domain, target_method->klass)->initialized;
 670                 MonoMethodHeader *mheader = mono_method_get_header (target_method);
 671
 672                 if (/*mono_metadata_signature_equal (method->signature, target_method->signature) */ method == target_method && *(td->ip + 5) == CEE_RET) {
 673                         int offset;
 674                         if (mono_interp_traceopt)
 675                                 g_print ("Optimize tail call of %s.%s\n", target_method->klass->name, target_method->name);
 676                         for (i = csignature->param_count - 1; i >= 0; --i)
 677                                 store_arg (td, i + csignature->hasthis);
 678
 679                         if (csignature->hasthis) {
 680                                 ADD_CODE(td, MINT_STTHIS);
 681                                 --td->sp;
 682                         }
 683                         ADD_CODE(td, MINT_BR_S);
 684                         offset = body_start_offset - ((td->new_ip - 1) - td->new_code);
 685                         ADD_CODE(td, offset);
 686                         if (!is_bb_start [td->ip + 5 - td->il_code])
 687                                 ++td->ip; /* gobble the CEE_RET if it isn't branched to */
 688                         td->ip += 5;
 689                         return;
 690                 } else {
 691                         /* mheader might not exist if this is a delegate invoc, etc */
 692                         if (mheader && *mheader->code == CEE_RET && called_inited) {
 693                                 if (mono_interp_traceopt)
 694                                         g_print ("Inline (empty) call of %s.%s\n", target_method->klass->name, target_method->name);
 695                                 for (i = 0; i < csignature->param_count; i++)
 696                                         ADD_CODE(td, MINT_POP); /*FIX: vt */
 697                                 if (csignature->hasthis) {
 698                                         if (virtual)
 699                                                 ADD_CODE(td, MINT_CKNULL);
 700                                         ADD_CODE(td, MINT_POP);
 701                                 }
 702                                 td->sp -= csignature->param_count + csignature->hasthis;
 703                                 td->ip += 5;
 704                                 return;
 705                         }
 706                 }
 707         }
 708         if (method->wrapper_type == MONO_WRAPPER_NONE && target_method != NULL) {
 709                 if (target_method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL)
 710                         target_method = mono_marshal_get_native_wrapper (target_method, FALSE, FALSE);
 711                 if (!virtual && target_method->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED)
 712                         target_method = mono_marshal_get_synchronized_wrapper (target_method);
 713         }
 714         g_assert (csignature->call_convention == MONO_CALL_DEFAULT || csignature->call_convention == MONO_CALL_C);
 715         td->sp -= csignature->param_count + csignature->hasthis;
 716         for (i = 0; i < csignature->param_count; ++i) {
 717                 if (td->sp [i + csignature->hasthis].type == STACK_TYPE_VT) {
 718                         gint32 size;
 719                         MonoClass *klass = mono_class_from_mono_type (csignature->params [i]);
 720                         if (csignature->pinvoke && method->wrapper_type != MONO_WRAPPER_NONE)
 721                                 size = mono_class_native_size (klass, NULL);
 722                         else
 723                                 size = mono_class_value_size (klass, NULL);
 724                         size = (size + 7) & ~7;
 725                         vt_stack_used += size;
 726                 }
 727         }
 728
 729         /* need to handle typedbyref ... */
 730         if (csignature->ret->type != MONO_TYPE_VOID) {
 731                 int mt = mint_type(csignature->ret);
 732                 MonoClass *klass = mono_class_from_mono_type (csignature->ret);
 733                 if (mt == MINT_TYPE_VT) {
 734                         if (csignature->pinvoke && method->wrapper_type != MONO_WRAPPER_NONE)
 735                                 vt_res_size = mono_class_native_size (klass, NULL);
 736                         else
 737                                 vt_res_size = mono_class_value_size (klass, NULL);
 738                         PUSH_VT(td, vt_res_size);
 739                 }
 740                 PUSH_TYPE(td, stack_type[mt], klass);
 741         } else
 742                 is_void = TRUE;
 743
 744         if (op >= 0) {
 745                 ADD_CODE(td, op);
 746 #if SIZEOF_VOID_P == 8
 747                 if (op == MINT_LDLEN)
 748                         ADD_CODE(td, MINT_CONV_I4_I8);
 749 #endif
 750         } else {
 751                 if (calli)
 752                         ADD_CODE(td, native ? MINT_CALLI_NAT : MINT_CALLI);
 753                 else if (virtual)
 754                         ADD_CODE(td, is_void ? MINT_VCALLVIRT : MINT_CALLVIRT);
 755                 else
 756                         ADD_CODE(td, is_void ? MINT_VCALL : MINT_CALL);
 757
 758                 if (calli) {
 759                         ADD_CODE(td, get_data_item_index (td, (void *)csignature));
 760                 } else {
 761                         ADD_CODE(td, get_data_item_index (td, (void *)mono_interp_get_runtime_method (domain, target_method, &error)));
 762                         mono_error_cleanup (&error); /* FIXME: don't swallow the error */
 763                 }
 764         }
 765         td->ip += 5;
 766         if (vt_stack_used != 0 || vt_res_size != 0) {
 767                 ADD_CODE(td, MINT_VTRESULT);
 768                 ADD_CODE(td, vt_res_size);
 769                 WRITE32(td, &vt_stack_used);
 770                 td->vt_sp -= vt_stack_used;
 771         }
 772 }
 773
 774 static void
 775 generate (MonoMethod *method, RuntimeMethod *rtm, unsigned char *is_bb_start)
 776 {
 777         MonoMethodHeader *header = mono_method_get_header (method);
 778         MonoMethodSignature *signature = mono_method_signature (method);
 779         MonoImage *image = method->klass->image;
 780         MonoDomain *domain = mono_domain_get ();
 781         MonoGenericContext *generic_context = NULL;
 782         MonoError error;
 783         int offset, mt;
 784         int i;
 785         int i32;
 786         MonoClass *klass;
 787         MonoClassField *field;
 788         const unsigned char *end;
 789         int new_in_start_offset;
 790         int body_start_offset;
 791         int target;
 792         guint32 token;
 793         TransformData td;
 794         int generating_code = 1;
 795
 796         if (mono_method_signature (method)->is_inflated)
 797                 generic_context = &((MonoMethodInflated *) method)->context;
 798
 799         memset(&td, 0, sizeof(td));
 800         td.method = method;
 801         td.rtm = rtm;
 802         td.is_bb_start = is_bb_start;
 803         td.il_code = header->code;
 804         td.code_size = header->code_size;
 805         td.header = header;
 806         td.max_code_size = td.code_size;
 807         td.new_code = (unsigned short *)g_malloc(td.max_code_size * sizeof(gushort));
 808         td.new_code_end = td.new_code + td.max_code_size;
 809         td.in_offsets = g_malloc0(header->code_size * sizeof(int));
 810         td.forward_refs = g_malloc(header->code_size * sizeof(int));
 811         td.stack_state = g_malloc0(header->code_size * sizeof(StackInfo *));
 812         td.stack_height = g_malloc(header->code_size * sizeof(int));
 813         td.vt_stack_size = g_malloc(header->code_size * sizeof(int));
 814         td.n_data_items = 0;
 815         td.max_data_items = 0;
 816         td.data_items = NULL;
 817         td.data_hash = g_hash_table_new (NULL, NULL);
 818         rtm->data_items = td.data_items;
 819         for (i = 0; i < header->code_size; i++) {
 820                 td.forward_refs [i] = -1;
 821                 td.stack_height [i] = -1;
 822         }
 823         td.new_ip = td.new_code;
 824         td.last_new_ip = NULL;
 825
 826         td.stack = g_malloc0(header->max_stack * sizeof(td.stack[0]));
 827         td.sp = td.stack;
 828         td.max_stack_height = 0;
 829
 830         for (i = 0; i < header->num_clauses; i++) {
 831                 MonoExceptionClause *c = header->clauses + i;
 832                 td.stack_height [c->handler_offset] = 0;
 833                 td.vt_stack_size [c->handler_offset] = 0;
 834                 td.is_bb_start [c->handler_offset] = 1;
 835                 if (c->flags == MONO_EXCEPTION_CLAUSE_NONE) {
 836                         td.stack_height [c->handler_offset] = 1;
 837                         td.stack_state [c->handler_offset] = g_malloc0(sizeof(StackInfo));
 838                         td.stack_state [c->handler_offset][0].type = STACK_TYPE_O;
 839                         td.stack_state [c->handler_offset][0].klass = NULL; /*FIX*/
 840                 }
 841         }
 842
 843         td.ip = header->code;
 844         end = td.ip + header->code_size;
 845
 846         if (mono_interp_traceopt) {
 847                 char *tmp = mono_disasm_code (NULL, method, td.ip, end);
 848                 char *name = mono_method_full_name (method, TRUE);
 849                 g_print ("Method %s, original code:\n", name);
 850                 g_print ("%s\n", tmp);
 851                 g_free (tmp);
 852                 g_free (name);
 853         }
 854
 855         for (i = 0; i < signature->param_count; i++)
 856                 store_inarg(&td, i);
 857
 858         body_start_offset = td.new_ip - td.new_code;
 859
 860         for (i = 0; i < header->num_locals; i++) {
 861                 int mt = mint_type(header->locals [i]);
 862                 if (mt == MINT_TYPE_VT || mt == MINT_TYPE_O) {
 863                         ADD_CODE(&td, MINT_INITLOCALS);
 864                         break;
 865                 }
 866         }
 867
 868         while (td.ip < end) {
 869                 int in_offset;
 870
 871                 g_assert (td.sp >= td.stack);
 872                 g_assert (td.vt_sp < 0x10000000);
 873                 in_offset = td.ip - header->code;
 874                 td.in_offsets [in_offset] = td.new_ip - td.new_code;
 875                 new_in_start_offset = td.new_ip - td.new_code;
 876                 td.in_start = td.ip;
 877                 while (td.forward_refs [in_offset] >= 0) {
 878                         int j = td.forward_refs [in_offset];
 879                         int slot;
 880                         td.forward_refs [in_offset] = td.forward_refs [j];
 881                         if (td.in_offsets [j] < 0) {
 882                                 int old_switch_offset = -td.in_offsets [j];
 883                                 int new_switch_offset = td.in_offsets [old_switch_offset];
 884                                 int switch_case = (j - old_switch_offset - 5) / 4;
 885                                 int n_cases = read32 (header->code + old_switch_offset + 1);
 886                                 offset = (td.new_ip - td.new_code) - (new_switch_offset + 2 * n_cases + 3);
 887                                 slot = new_switch_offset + 3 + 2 * switch_case;
 888                                 td.new_code [slot] = * (unsigned short *)(&offset);
 889                                 td.new_code [slot + 1] = * ((unsigned short *)&offset + 1);
 890                         } else {
 891                                 int op = td.new_code [td.in_offsets [j]];
 892                                 if (mono_interp_opargtype [op] == MintOpShortBranch) {
 893                                         offset = (td.new_ip - td.new_code) - td.in_offsets [j];
 894                                         g_assert (offset <= 32767);
 895                                         slot = td.in_offsets [j] + 1;
 896                                         td.new_code [slot] = offset;
 897                                 } else {
 898                                         offset = (td.new_ip - td.new_code) - td.in_offsets [j];
 899                                         slot = td.in_offsets [j] + 1;
 900                                         td.new_code [slot] = * (unsigned short *)(&offset);
 901                                         td.new_code [slot + 1] = * ((unsigned short *)&offset + 1);
 902                                 }
 903                         }
 904                 }
 905                 if (td.stack_height [in_offset] >= 0) {
 906                         g_assert (is_bb_start [in_offset]);
 907                         if (td.stack_height [in_offset] > 0)
 908                                 memcpy (td.stack, td.stack_state [in_offset], td.stack_height [in_offset] * sizeof(td.stack [0]));
 909                         td.sp = td.stack + td.stack_height [in_offset];
 910                         td.vt_sp = td.vt_stack_size [in_offset];
 911                 }
 912                 if (is_bb_start [in_offset]) {
 913                         generating_code = 1;
 914                 }
 915                 if (!generating_code) {
 916                         while (td.ip < end && !is_bb_start [td.ip - td.il_code])
 917                                 ++td.ip;
 918                         continue;
 919                 }
 920                 if (mono_interp_traceopt > 1) {
 921                         printf("IL_%04lx %s %-10s -> IL_%04lx, sp %ld, %s %-12s vt_sp %u (max %u)\n",
 922                                 td.ip - td.il_code,
 923                                 td.is_bb_start [td.ip - td.il_code] == 3 ? "<>" :
 924                                 td.is_bb_start [td.ip - td.il_code] == 2 ? "< " :
 925                                 td.is_bb_start [td.ip - td.il_code] == 1 ? " >" : "  ",
 926                                 mono_opcode_name (*td.ip), td.new_ip - td.new_code, td.sp - td.stack,
 927                                 td.sp > td.stack ? stack_type_string [td.sp [-1].type] : "  ",
 928                                 (td.sp > td.stack && (td.sp [-1].type == STACK_TYPE_O || td.sp [-1].type == STACK_TYPE_VT)) ? (td.sp [-1].klass == NULL ? "?" : td.sp [-1].klass->name) : "",
 929                                 td.vt_sp, td.max_vt_sp);
 930                 }
 931                 switch (*td.ip) {
 932                 case CEE_NOP:
 933                         /* lose it */
 934                         ++td.ip;
 935                         break;
 936                 case CEE_BREAK:
 937                         SIMPLE_OP(td, MINT_BREAK);
 938                         break;
 939                 case CEE_LDARG_0:
 940                 case CEE_LDARG_1:
 941                 case CEE_LDARG_2:
 942                 case CEE_LDARG_3:
 943                         load_arg (&td, *td.ip - CEE_LDARG_0);
 944                         ++td.ip;
 945                         break;
 946                 case CEE_LDLOC_0:
 947                 case CEE_LDLOC_1:
 948                 case CEE_LDLOC_2:
 949                 case CEE_LDLOC_3:
 950                         load_local (&td, *td.ip - CEE_LDLOC_0);
 951                         ++td.ip;
 952                         break;
 953                 case CEE_STLOC_0:
 954                 case CEE_STLOC_1:
 955                 case CEE_STLOC_2:
 956                 case CEE_STLOC_3:
 957                         store_local (&td, *td.ip - CEE_STLOC_0);
 958                         ++td.ip;
 959                         break;
 960                 case CEE_LDARG_S:
 961                         load_arg (&td, ((guint8 *)td.ip)[1]);
 962                         td.ip += 2;
 963                         break;
 964                 case CEE_LDARGA_S: {
 965                         int n = ((guint8 *)td.ip)[1];
 966                         if (n == 0 && signature->hasthis)
 967                                 ADD_CODE(&td, MINT_LDTHISA);
 968                         else {
 969                                 ADD_CODE(&td, MINT_LDARGA);
 970                                 ADD_CODE(&td, td.rtm->arg_offsets [n - signature->hasthis]);
 971                         }
 972                         PUSH_SIMPLE_TYPE(&td, STACK_TYPE_MP);
 973                         td.ip += 2;
 974                         break;
 975                 }
 976                 case CEE_STARG_S:
 977                         store_arg (&td, ((guint8 *)td.ip)[1]);
 978                         td.ip += 2;
 979                         break;
 980                 case CEE_LDLOC_S:
 981                         load_local (&td, ((guint8 *)td.ip)[1]);
 982                         td.ip += 2;
 983                         break;
 984                 case CEE_LDLOCA_S:
 985                         ADD_CODE(&td, MINT_LDLOCA_S);
 986                         ADD_CODE(&td, td.rtm->local_offsets [((guint8 *)td.ip)[1]]);
 987                         PUSH_SIMPLE_TYPE(&td, STACK_TYPE_MP);
 988                         td.ip += 2;
 989                         break;
 990                 case CEE_STLOC_S:
 991                         store_local (&td, ((guint8 *)td.ip)[1]);
 992                         td.ip += 2;
 993                         break;
 994                 case CEE_LDNULL:
 995                         SIMPLE_OP(td, MINT_LDNULL);
 996                         PUSH_TYPE(&td, STACK_TYPE_O, NULL);
 997                         break;
 998                 case CEE_LDC_I4_M1:
 999                         SIMPLE_OP(td, MINT_LDC_I4_M1);
1000                         PUSH_SIMPLE_TYPE(&td, STACK_TYPE_I4);
1001                         break;
1002                 case CEE_LDC_I4_0:
1003                         if (!td.is_bb_start[td.ip + 1 - td.il_code] && td.ip [1] == 0xfe && td.ip [2] == CEE_CEQ &&
1004                                 td.sp > td.stack && td.sp [-1].type == STACK_TYPE_I4) {
1005                                 SIMPLE_OP(td, MINT_CEQ0_I4);
1006                                 td.ip += 2;
1007                         } else {
1008                                 SIMPLE_OP(td, MINT_LDC_I4_0);
1009                                 PUSH_SIMPLE_TYPE(&td, STACK_TYPE_I4);
1010                         }
1011                         break;
1012                 case CEE_LDC_I4_1:
1013                         if (!td.is_bb_start[td.ip + 1 - td.il_code] &&
1014                                 (td.ip [1] == CEE_ADD || td.ip [1] == CEE_SUB) && td.sp [-1].type == STACK_TYPE_I4) {
1015                                 ADD_CODE(&td, td.ip [1] == CEE_ADD ? MINT_ADD1_I4 : MINT_SUB1_I4);
1016                                 td.ip += 2;
1017                         } else {
1018                                 SIMPLE_OP(td, MINT_LDC_I4_1);
1019                                 PUSH_SIMPLE_TYPE(&td, STACK_TYPE_I4);
1020                         }
1021                         break;
1022                 case CEE_LDC_I4_2:
1023                 case CEE_LDC_I4_3:
1024                 case CEE_LDC_I4_4:
1025                 case CEE_LDC_I4_5:
1026                 case CEE_LDC_I4_6:
1027                 case CEE_LDC_I4_7:
1028                 case CEE_LDC_I4_8:
1029                         SIMPLE_OP(td, (*td.ip - CEE_LDC_I4_0) + MINT_LDC_I4_0);
1030                         PUSH_SIMPLE_TYPE(&td, STACK_TYPE_I4);
1031                         break;
1032                 case CEE_LDC_I4_S:
1033                         ADD_CODE(&td, MINT_LDC_I4_S);
1034                         ADD_CODE(&td, ((gint8 *) td.ip) [1]);
1035                         td.ip += 2;
1036                         PUSH_SIMPLE_TYPE(&td, STACK_TYPE_I4);
1037                         break;
1038                 case CEE_LDC_I4:
1039                         i32 = read32 (td.ip + 1);
1040                         ADD_CODE(&td, MINT_LDC_I4);
1041                         WRITE32(&td, &i32);
1042                         td.ip += 5;
1043                         PUSH_SIMPLE_TYPE(&td, STACK_TYPE_I4);
1044                         break;
1045                 case CEE_LDC_I8: {
1046                         gint64 val = read64 (td.ip + 1);
1047                         ADD_CODE(&td, MINT_LDC_I8);
1048                         WRITE64(&td, &val);
1049                         td.ip += 9;
1050                         PUSH_SIMPLE_TYPE(&td, STACK_TYPE_I8);
1051                         break;
1052                 }
1053                 case CEE_LDC_R4: {
1054                         float val;
1055                         readr4 (td.ip + 1, &val);
1056                         ADD_CODE(&td, MINT_LDC_R4);
1057                         WRITE32(&td, &val);
1058                         td.ip += 5;
1059                         PUSH_SIMPLE_TYPE(&td, STACK_TYPE_R8);
1060                         break;
1061                 }
1062                 case CEE_LDC_R8: {
1063                         double val;
1064                         readr8 (td.ip + 1, &val);
1065                         ADD_CODE(&td, MINT_LDC_R8);
1066                         WRITE64(&td, &val);
1067                         td.ip += 9;
1068                         PUSH_SIMPLE_TYPE(&td, STACK_TYPE_R8);
1069                         break;
1070                 }
1071                 case CEE_DUP: {
1072                         int type = td.sp [-1].type;
1073                         MonoClass *klass = td.sp [-1].klass;
1074                         if (td.sp [-1].type == STACK_TYPE_VT) {
1075                                 gint32 size = mono_class_value_size (klass, NULL);
1076                                 PUSH_VT(&td, size);
1077                                 ADD_CODE(&td, MINT_DUP_VT);
1078                                 WRITE32(&td, &size);
1079                                 td.ip ++;
1080                         } else
1081                                 SIMPLE_OP(td, MINT_DUP);
1082                         PUSH_TYPE(&td, type, klass);
1083                         break;
1084                 }
1085                 case CEE_POP:
1086                         CHECK_STACK(&td, 1);
1087                         SIMPLE_OP(td, MINT_POP);
1088                         if (td.sp [-1].type == STACK_TYPE_VT) {
1089                                 int size = mono_class_value_size (td.sp [-1].klass, NULL);
1090                                 size = (size + 7) & ~7;
1091                                 ADD_CODE(&td, MINT_VTRESULT);
1092                                 ADD_CODE(&td, 0);
1093                                 WRITE32(&td, &size);
1094                                 td.vt_sp -= size;
1095                         }
1096                         --td.sp;
1097                         break;
1098                 case CEE_JMP: {
1099                         MonoMethod *m;
1100                         if (td.sp > td.stack)
1101                                 g_warning ("CEE_JMP: stack must be empty");
1102                         token = read32 (td.ip + 1);
1103                         m = mono_get_method_full (image, token, NULL, generic_context);
1104                         ADD_CODE (&td, MINT_JMP);
1105                         ADD_CODE (&td, get_data_item_index (&td, mono_interp_get_runtime_method (domain, m, &error)));
1106                         mono_error_cleanup (&error); /* FIXME: don't swallow the error */
1107                         td.ip += 5;
1108                         break;
1109                 }
1110                 case CEE_CALLVIRT: /* Fall through */
1111                 case CEE_CALLI:    /* Fall through */
1112                 case CEE_CALL: {
1113                         interp_transform_call (&td, method, NULL, domain, generic_context, is_bb_start, body_start_offset);
1114                         break;
1115                 }
1116                 case CEE_RET: {
1117                         int vt_size = 0;
1118                         if (signature->ret->type != MONO_TYPE_VOID) {
1119                                 --td.sp;
1120                                 MonoClass *klass = mono_class_from_mono_type (signature->ret);
1121                                 if (mint_type (&klass->byval_arg) == MINT_TYPE_VT) {
1122                                         vt_size = mono_class_value_size (klass, NULL);
1123                                         vt_size = (vt_size + 7) & ~7;
1124                                 }
1125                         }
1126                         if (td.sp > td.stack)
1127                                 g_warning ("%s.%s: CEE_RET: more values on stack: %d", td.method->klass->name, td.method->name, td.sp - td.stack);
1128                         if (td.vt_sp != vt_size)
1129                                 g_error ("%s.%s: CEE_RET: value type stack: %d vs. %d", td.method->klass->name, td.method->name, td.vt_sp, vt_size);
1130                         if (vt_size == 0)
1131                                 SIMPLE_OP(td, signature->ret->type == MONO_TYPE_VOID ? MINT_RET_VOID : MINT_RET);
1132                         else {
1133                                 ADD_CODE(&td, MINT_RET_VT);
1134                                 WRITE32(&td, &vt_size);
1135                                 ++td.ip;
1136                         }
1137                         generating_code = 0;
1138                         break;
1139                 }
1140                 case CEE_BR:
1141                         handle_branch (&td, MINT_BR_S, MINT_BR, 5 + read32 (td.ip + 1));
1142                         td.ip += 5;
1143                         generating_code = 0;
1144                         break;
1145                 case CEE_BR_S:
1146                         handle_branch (&td, MINT_BR_S, MINT_BR, 2 + (gint8)td.ip [1]);
1147                         td.ip += 2;
1148                         generating_code = 0;
1149                         break;
1150                 case CEE_BRFALSE:
1151                         one_arg_branch (&td, MINT_BRFALSE_I4, 5 + read32 (td.ip + 1));
1152                         td.ip += 5;
1153                         break;
1154                 case CEE_BRFALSE_S:
1155                         one_arg_branch (&td, MINT_BRFALSE_I4, 2 + (gint8)td.ip [1]);
1156                         td.ip += 2;
1157                         break;
1158                 case CEE_BRTRUE:
1159                         one_arg_branch (&td, MINT_BRTRUE_I4, 5 + read32 (td.ip + 1));
1160                         td.ip += 5;
1161                         break;
1162                 case CEE_BRTRUE_S:
1163                         one_arg_branch (&td, MINT_BRTRUE_I4, 2 + (gint8)td.ip [1]);
1164                         td.ip += 2;
1165                         break;
1166                 case CEE_BEQ:
1167                         two_arg_branch (&td, MINT_BEQ_I4, 5 + read32 (td.ip + 1));
1168                         td.ip += 5;
1169                         break;
1170                 case CEE_BEQ_S:
1171                         two_arg_branch (&td, MINT_BEQ_I4, 2 + (gint8) td.ip [1]);
1172                         td.ip += 2;
1173                         break;
1174                 case CEE_BGE:
1175                         two_arg_branch (&td, MINT_BGE_I4, 5 + read32 (td.ip + 1));
1176                         td.ip += 5;
1177                         break;
1178                 case CEE_BGE_S:
1179                         two_arg_branch (&td, MINT_BGE_I4, 2 + (gint8) td.ip [1]);
1180                         td.ip += 2;
1181                         break;
1182                 case CEE_BGT:
1183                         two_arg_branch (&td, MINT_BGT_I4, 5 + read32 (td.ip + 1));
1184                         td.ip += 5;
1185                         break;
1186                 case CEE_BGT_S:
1187                         two_arg_branch (&td, MINT_BGT_I4, 2 + (gint8) td.ip [1]);
1188                         td.ip += 2;
1189                         break;
1190                 case CEE_BLT:
1191                         two_arg_branch (&td, MINT_BLT_I4, 5 + read32 (td.ip + 1));
1192                         td.ip += 5;
1193                         break;
1194                 case CEE_BLT_S:
1195                         two_arg_branch (&td, MINT_BLT_I4, 2 + (gint8) td.ip [1]);
1196                         td.ip += 2;
1197                         break;
1198                 case CEE_BLE:
1199                         two_arg_branch (&td, MINT_BLE_I4, 5 + read32 (td.ip + 1));
1200                         td.ip += 5;
1201                         break;
1202                 case CEE_BLE_S:
1203                         two_arg_branch (&td, MINT_BLE_I4, 2 + (gint8) td.ip [1]);
1204                         td.ip += 2;
1205                         break;
1206                 case CEE_BNE_UN:
1207                         two_arg_branch (&td, MINT_BNE_UN_I4, 5 + read32 (td.ip + 1));
1208                         td.ip += 5;
1209                         break;
1210                 case CEE_BNE_UN_S:
1211                         two_arg_branch (&td, MINT_BNE_UN_I4, 2 + (gint8) td.ip [1]);
1212                         td.ip += 2;
1213                         break;
1214                 case CEE_BGE_UN:
1215                         two_arg_branch (&td, MINT_BGE_UN_I4, 5 + read32 (td.ip + 1));
1216                         td.ip += 5;
1217                         break;
1218                 case CEE_BGE_UN_S:
1219                         two_arg_branch (&td, MINT_BGE_UN_I4, 2 + (gint8) td.ip [1]);
1220                         td.ip += 2;
1221                         break;
1222                 case CEE_BGT_UN:
1223                         two_arg_branch (&td, MINT_BGT_UN_I4, 5 + read32 (td.ip + 1));
1224                         td.ip += 5;
1225                         break;
1226                 case CEE_BGT_UN_S:
1227                         two_arg_branch (&td, MINT_BGT_UN_I4, 2 + (gint8) td.ip [1]);
1228                         td.ip += 2;
1229                         break;
1230                 case CEE_BLE_UN:
1231                         two_arg_branch (&td, MINT_BLE_UN_I4, 5 + read32 (td.ip + 1));
1232                         td.ip += 5;
1233                         break;
1234                 case CEE_BLE_UN_S:
1235                         two_arg_branch (&td, MINT_BLE_UN_I4, 2 + (gint8) td.ip [1]);
1236                         td.ip += 2;
1237                         break;
1238                 case CEE_BLT_UN:
1239                         two_arg_branch (&td, MINT_BLT_UN_I4, 5 + read32 (td.ip + 1));
1240                         td.ip += 5;
1241                         break;
1242                 case CEE_BLT_UN_S:
1243                         two_arg_branch (&td, MINT_BLT_UN_I4, 2 + (gint8) td.ip [1]);
1244                         td.ip += 2;
1245                         break;
1246                 case CEE_SWITCH: {
1247                         guint32 n;
1248                         const unsigned char *next_ip;
1249                         const unsigned char *base_ip = td.ip;
1250                         unsigned short *next_new_ip;
1251                         ++td.ip;
1252                         n = read32 (td.ip);
1253                         ADD_CODE(&td, MINT_SWITCH);
1254                         ADD_CODE(&td, * (unsigned short *)(&n));
1255                         ADD_CODE(&td, * ((unsigned short *)&n + 1));
1256                         td.ip += 4;
1257                         next_ip = td.ip + n * 4;
1258                         next_new_ip = td.new_ip + n * 2;
1259                         for (i = 0; i < n; i++) {
1260                                 offset = read32 (td.ip);
1261                                 target = next_ip - td.il_code + offset;
1262                                 if (offset < 0)
1263                                         target = td.in_offsets [target] - (next_new_ip - td.new_code);
1264                                 else {
1265                                         int prev = td.forward_refs [target];
1266                                         td.forward_refs [td.ip - td.il_code] = prev;
1267                                         td.forward_refs [target] = td.ip - td.il_code;
1268                                         td.in_offsets [td.ip - td.il_code] = - (base_ip - td.il_code);
1269                                 }
1270                                 ADD_CODE(&td, * (unsigned short *)(&target));
1271                                 ADD_CODE(&td, * ((unsigned short *)&target + 1));
1272                                 td.ip += 4;
1273                         }
1274                         --td.sp;
1275                         break;
1276                 }
1277                 case CEE_LDIND_I1:
1278                         CHECK_STACK (&td, 1);
1279                         SIMPLE_OP (td, MINT_LDIND_I1);
1280                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
1281                         break;
1282                 case CEE_LDIND_U1:
1283                         CHECK_STACK (&td, 1);
1284                         SIMPLE_OP (td, MINT_LDIND_U1);
1285                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
1286                         break;
1287                 case CEE_LDIND_I2:
1288                         CHECK_STACK (&td, 1);
1289                         SIMPLE_OP (td, MINT_LDIND_I2);
1290                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
1291                         break;
1292                 case CEE_LDIND_U2:
1293                         CHECK_STACK (&td, 1);
1294                         SIMPLE_OP (td, MINT_LDIND_U2);
1295                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
1296                         break;
1297                 case CEE_LDIND_I4:
1298                         CHECK_STACK (&td, 1);
1299                         SIMPLE_OP (td, MINT_LDIND_I4);
1300                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
1301                         break;
1302                 case CEE_LDIND_U4:
1303                         CHECK_STACK (&td, 1);
1304                         SIMPLE_OP (td, MINT_LDIND_U4);
1305                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
1306                         break;
1307                 case CEE_LDIND_I8:
1308                         CHECK_STACK (&td, 1);
1309                         SIMPLE_OP (td, MINT_LDIND_I8);
1310                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I8);
1311                         break;
1312                 case CEE_LDIND_I:
1313                         CHECK_STACK (&td, 1);
1314                         SIMPLE_OP (td, MINT_LDIND_I);
1315                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I);
1316                         break;
1317                 case CEE_LDIND_R4:
1318                         CHECK_STACK (&td, 1);
1319                         SIMPLE_OP (td, MINT_LDIND_R4);
1320                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_R8);
1321                         break;
1322                 case CEE_LDIND_R8:
1323                         CHECK_STACK (&td, 1);
1324                         SIMPLE_OP (td, MINT_LDIND_R8);
1325                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_R8);
1326                         break;
1327                 case CEE_LDIND_REF:
1328                         CHECK_STACK (&td, 1);
1329                         SIMPLE_OP (td, MINT_LDIND_REF);
1330                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_O);
1331                         break;
1332                 case CEE_STIND_REF:
1333                         CHECK_STACK (&td, 2);
1334                         SIMPLE_OP (td, MINT_STIND_REF);
1335                         td.sp -= 2;
1336                         break;
1337                 case CEE_STIND_I1:
1338                         CHECK_STACK (&td, 2);
1339                         SIMPLE_OP (td, MINT_STIND_I1);
1340                         td.sp -= 2;
1341                         break;
1342                 case CEE_STIND_I2:
1343                         CHECK_STACK (&td, 2);
1344                         SIMPLE_OP (td, MINT_STIND_I2);
1345                         td.sp -= 2;
1346                         break;
1347                 case CEE_STIND_I4:
1348                         CHECK_STACK (&td, 2);
1349                         SIMPLE_OP (td, MINT_STIND_I4);
1350                         td.sp -= 2;
1351                         break;
1352                 case CEE_STIND_I:
1353                         CHECK_STACK (&td, 2);
1354                         SIMPLE_OP (td, MINT_STIND_I);
1355                         td.sp -= 2;
1356                         break;
1357                 case CEE_STIND_I8:
1358                         CHECK_STACK (&td, 2);
1359                         SIMPLE_OP (td, MINT_STIND_I8);
1360                         td.sp -= 2;
1361                         break;
1362                 case CEE_STIND_R4:
1363                         CHECK_STACK (&td, 2);
1364                         SIMPLE_OP (td, MINT_STIND_R4);
1365                         td.sp -= 2;
1366                         break;
1367                 case CEE_STIND_R8:
1368                         CHECK_STACK (&td, 2);
1369                         SIMPLE_OP (td, MINT_STIND_R8);
1370                         td.sp -= 2;
1371                         break;
1372                 case CEE_ADD:
1373                         binary_arith_op(&td, MINT_ADD_I4);
1374                         ++td.ip;
1375                         break;
1376                 case CEE_SUB:
1377                         binary_arith_op(&td, MINT_SUB_I4);
1378                         ++td.ip;
1379                         break;
1380                 case CEE_MUL:
1381                         binary_arith_op(&td, MINT_MUL_I4);
1382                         ++td.ip;
1383                         break;
1384                 case CEE_DIV:
1385                         binary_arith_op(&td, MINT_DIV_I4);
1386                         ++td.ip;
1387                         break;
1388                 case CEE_DIV_UN:
1389                         binary_arith_op(&td, MINT_DIV_UN_I4);
1390                         ++td.ip;
1391                         break;
1392                 case CEE_REM:
1393                         binary_int_op (&td, MINT_REM_I4);
1394                         ++td.ip;
1395                         break;
1396                 case CEE_REM_UN:
1397                         binary_int_op (&td, MINT_REM_UN_I4);
1398                         ++td.ip;
1399                         break;
1400                 case CEE_AND:
1401                         binary_int_op (&td, MINT_AND_I4);
1402                         ++td.ip;
1403                         break;
1404                 case CEE_OR:
1405                         binary_int_op (&td, MINT_OR_I4);
1406                         ++td.ip;
1407                         break;
1408                 case CEE_XOR:
1409                         binary_int_op (&td, MINT_XOR_I4);
1410                         ++td.ip;
1411                         break;
1412                 case CEE_SHL:
1413                         shift_op (&td, MINT_SHL_I4);
1414                         ++td.ip;
1415                         break;
1416                 case CEE_SHR:
1417                         shift_op (&td, MINT_SHR_I4);
1418                         ++td.ip;
1419                         break;
1420                 case CEE_SHR_UN:
1421                         shift_op (&td, MINT_SHR_UN_I4);
1422                         ++td.ip;
1423                         break;
1424                 case CEE_NEG:
1425                         unary_arith_op (&td, MINT_NEG_I4);
1426                         ++td.ip;
1427                         break;
1428                 case CEE_NOT:
1429                         unary_arith_op (&td, MINT_NOT_I4);
1430                         ++td.ip;
1431                         break;
1432                 case CEE_CONV_U1:
1433                         CHECK_STACK (&td, 1);
1434                         switch (td.sp [-1].type) {
1435                         case STACK_TYPE_R8:
1436                                 ADD_CODE(&td, MINT_CONV_U1_R8);
1437                                 break;
1438                         case STACK_TYPE_I4:
1439                                 ADD_CODE(&td, MINT_CONV_U1_I4);
1440                                 break;
1441                         case STACK_TYPE_I8:
1442                                 ADD_CODE(&td, MINT_CONV_U1_I8);
1443                                 break;
1444                         default:
1445                                 g_assert_not_reached ();
1446                         }
1447                         ++td.ip;
1448                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
1449                         break;
1450                 case CEE_CONV_I1:
1451                         CHECK_STACK (&td, 1);
1452                         switch (td.sp [-1].type) {
1453                         case STACK_TYPE_R8:
1454                                 ADD_CODE(&td, MINT_CONV_I1_R8);
1455                                 break;
1456                         case STACK_TYPE_I4:
1457                                 ADD_CODE(&td, MINT_CONV_I1_I4);
1458                                 break;
1459                         case STACK_TYPE_I8:
1460                                 ADD_CODE(&td, MINT_CONV_I1_I8);
1461                                 break;
1462                         default:
1463                                 g_assert_not_reached ();
1464                         }
1465                         ++td.ip;
1466                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
1467                         break;
1468                 case CEE_CONV_U2:
1469                         CHECK_STACK (&td, 1);
1470                         switch (td.sp [-1].type) {
1471                         case STACK_TYPE_R8:
1472                                 ADD_CODE(&td, MINT_CONV_U2_R8);
1473                                 break;
1474                         case STACK_TYPE_I4:
1475                                 ADD_CODE(&td, MINT_CONV_U2_I4);
1476                                 break;
1477                         case STACK_TYPE_I8:
1478                                 ADD_CODE(&td, MINT_CONV_U2_I8);
1479                                 break;
1480                         default:
1481                                 g_assert_not_reached ();
1482                         }
1483                         ++td.ip;
1484                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
1485                         break;
1486                 case CEE_CONV_I2:
1487                         CHECK_STACK (&td, 1);
1488                         switch (td.sp [-1].type) {
1489                         case STACK_TYPE_R8:
1490                                 ADD_CODE(&td, MINT_CONV_I2_R8);
1491                                 break;
1492                         case STACK_TYPE_I4:
1493                                 ADD_CODE(&td, MINT_CONV_I2_I4);
1494                                 break;
1495                         case STACK_TYPE_I8:
1496                                 ADD_CODE(&td, MINT_CONV_I2_I8);
1497                                 break;
1498                         default:
1499                                 g_assert_not_reached ();
1500                         }
1501                         ++td.ip;
1502                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
1503                         break;
1504                 case CEE_CONV_U:
1505                         CHECK_STACK (&td, 1);
1506                         switch (td.sp [-1].type) {
1507                         case STACK_TYPE_R8:
1508 #if SIZEOF_VOID_P == 4
1509                                 ADD_CODE(&td, MINT_CONV_U4_R8);
1510 #else
1511                                 ADD_CODE(&td, MINT_CONV_U8_R8);
1512 #endif
1513                                 break;
1514                         case STACK_TYPE_I4:
1515 #if SIZEOF_VOID_P == 8
1516                                 ADD_CODE(&td, MINT_CONV_U8_I4);
1517 #endif
1518                                 break;
1519                         case STACK_TYPE_I8:
1520 #if SIZEOF_VOID_P == 4
1521                                 ADD_CODE(&td, MINT_CONV_U4_I8);
1522 #endif
1523                                 break;
1524                         case STACK_TYPE_MP:
1525                                 break;
1526                         default:
1527                                 g_assert_not_reached ();
1528                         }
1529                         ++td.ip;
1530                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I);
1531                         break;
1532                 case CEE_CONV_I:
1533                         CHECK_STACK (&td, 1);
1534                         switch (td.sp [-1].type) {
1535                         case STACK_TYPE_R8:
1536 #if SIZEOF_VOID_P == 8
1537                                 ADD_CODE(&td, MINT_CONV_I8_R8);
1538 #else
1539                                 ADD_CODE(&td, MINT_CONV_I4_R8);
1540 #endif
1541                                 break;
1542                         case STACK_TYPE_I4:
1543 #if SIZEOF_VOID_P == 8
1544                                 ADD_CODE(&td, MINT_CONV_I8_I4);
1545 #endif
1546                                 break;
1547                         case STACK_TYPE_O:
1548                                 break;
1549                         case STACK_TYPE_MP:
1550                                 break;
1551                         case STACK_TYPE_I8:
1552 #if SIZEOF_VOID_P == 4
1553                                 ADD_CODE(&td, MINT_CONV_I4_I8);
1554 #endif
1555                                 break;
1556                         default:
1557                                 g_assert_not_reached ();
1558                         }
1559                         ++td.ip;
1560                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I);
1561                         break;
1562                 case CEE_CONV_U4:
1563                         CHECK_STACK (&td, 1);
1564                         switch (td.sp [-1].type) {
1565                         case STACK_TYPE_R8:
1566                                 ADD_CODE(&td, MINT_CONV_U4_R8);
1567                                 break;
1568                         case STACK_TYPE_I4:
1569                                 break;
1570                         case STACK_TYPE_I8:
1571                                 ADD_CODE(&td, MINT_CONV_U4_I8);
1572                                 break;
1573                         case STACK_TYPE_MP:
1574 #if SIZEOF_VOID_P == 8
1575                                 ADD_CODE(&td, MINT_CONV_U4_I8);
1576 #endif
1577                                 break;
1578                         default:
1579                                 g_assert_not_reached ();
1580                         }
1581                         ++td.ip;
1582                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
1583                         break;
1584                 case CEE_CONV_I4:
1585                         CHECK_STACK (&td, 1);
1586                         switch (td.sp [-1].type) {
1587                         case STACK_TYPE_R8:
1588                                 ADD_CODE(&td, MINT_CONV_I4_R8);
1589                                 break;
1590                         case STACK_TYPE_I4:
1591                                 break;
1592                         case STACK_TYPE_I8:
1593                                 ADD_CODE(&td, MINT_CONV_I4_I8);
1594                                 break;
1595                         case STACK_TYPE_MP:
1596 #if SIZEOF_VOID_P == 8
1597                                 ADD_CODE(&td, MINT_CONV_I4_I8);
1598 #endif
1599                                 break;
1600                         default:
1601                                 g_assert_not_reached ();
1602                         }
1603                         ++td.ip;
1604                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
1605                         break;
1606                 case CEE_CONV_I8:
1607                         CHECK_STACK (&td, 1);
1608                         switch (td.sp [-1].type) {
1609                         case STACK_TYPE_R8:
1610                                 ADD_CODE(&td, MINT_CONV_I8_R8);
1611                                 break;
1612                         case STACK_TYPE_I4:
1613                                 ADD_CODE(&td, MINT_CONV_I8_I4);
1614                                 break;
1615                         case STACK_TYPE_I8:
1616                                 break;
1617                         case STACK_TYPE_MP:
1618 #if SIZEOF_VOID_P == 4
1619                                 ADD_CODE(&td, MINT_CONV_I8_I4);
1620 #endif
1621                                 break;
1622                         default:
1623                                 g_assert_not_reached ();
1624                         }
1625                         ++td.ip;
1626                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I8);
1627                         break;
1628                 case CEE_CONV_R4:
1629                         CHECK_STACK (&td, 1);
1630                         switch (td.sp [-1].type) {
1631                         case STACK_TYPE_R8:
1632                                 ADD_CODE(&td, MINT_CONV_R4_R8);
1633                                 break;
1634                         case STACK_TYPE_I8:
1635                                 ADD_CODE(&td, MINT_CONV_R4_I8);
1636                                 break;
1637                         case STACK_TYPE_I4:
1638                                 ADD_CODE(&td, MINT_CONV_R4_I4);
1639                                 break;
1640                         default:
1641                                 g_assert_not_reached ();
1642                         }
1643                         ++td.ip;
1644                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_R8);
1645                         break;
1646                 case CEE_CONV_R8:
1647                         CHECK_STACK (&td, 1);
1648                         switch (td.sp [-1].type) {
1649                         case STACK_TYPE_I4:
1650                                 ADD_CODE(&td, MINT_CONV_R8_I4);
1651                                 break;
1652                         case STACK_TYPE_I8:
1653                                 ADD_CODE(&td, MINT_CONV_R8_I8);
1654                                 break;
1655                         case STACK_TYPE_R8:
1656                                 break;
1657                         default:
1658                                 g_assert_not_reached ();
1659                         }
1660                         ++td.ip;
1661                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_R8);
1662                         break;
1663                 case CEE_CONV_U8:
1664                         CHECK_STACK (&td, 1);
1665                         switch (td.sp [-1].type) {
1666                         case STACK_TYPE_I4:
1667                                 ADD_CODE(&td, MINT_CONV_U8_I4);
1668                                 break;
1669                         case STACK_TYPE_I8:
1670                                 break;
1671                         case STACK_TYPE_R8:
1672                                 ADD_CODE(&td, MINT_CONV_U8_R8);
1673                                 break;
1674                         case STACK_TYPE_MP:
1675 #if SIZEOF_VOID_P == 4
1676                                 ADD_CODE(&td, MINT_CONV_U8_I4);
1677 #endif
1678                                 break;
1679                         default:
1680                                 g_assert_not_reached ();
1681                         }
1682                         ++td.ip;
1683                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I8);
1684                         break;
1685 #if 0
1686                 case CEE_CPOBJ: {
1687                         MonoClass *vtklass;
1688                         ++ip;
1689                         vtklass = mono_class_get_full (image, read32 (ip), generic_context);
1690                         ip += 4;
1691                         sp -= 2;
1692                         memcpy (sp [0].data.p, sp [1].data.p, mono_class_value_size (vtklass, NULL));
1693                         break;
1694                 }
1695 #endif
1696                 case CEE_LDOBJ: {
1697                         int size;
1698                         CHECK_STACK (&td, 1);
1699
1700                         token = read32 (td.ip + 1);
1701
1702                         if (method->wrapper_type != MONO_WRAPPER_NONE)
1703                                 klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
1704                         else
1705                                 klass = mono_class_get_full (image, token, generic_context);
1706
1707                         ADD_CODE(&td, MINT_LDOBJ);
1708                         ADD_CODE(&td, get_data_item_index(&td, klass));
1709                         g_error ("data.klass");
1710                         if (klass->byval_arg.type == MONO_TYPE_VALUETYPE && !klass->byval_arg.data.klass->enumtype) {
1711                                 size = mono_class_value_size (klass, NULL);
1712                                 PUSH_VT(&td, size);
1713                         }
1714                         td.ip += 5;
1715                         SET_TYPE(td.sp - 1, stack_type[mint_type(&klass->byval_arg)], klass);
1716                         break;
1717                 }
1718                 case CEE_LDSTR: {
1719                         MonoString *s;
1720                         token = mono_metadata_token_index (read32 (td.ip + 1));
1721                         td.ip += 5;
1722                         if (method->wrapper_type != MONO_WRAPPER_NONE) {
1723                                 s = mono_string_new_wrapper(
1724                                         mono_method_get_wrapper_data (method, token));
1725                         }
1726                         else
1727                                 s = mono_ldstr (domain, image, token);
1728                         ADD_CODE(&td, MINT_LDSTR);
1729                         ADD_CODE(&td, get_data_item_index (&td, s));
1730                         PUSH_TYPE(&td, STACK_TYPE_O, mono_defaults.string_class);
1731                         break;
1732                 }
1733                 case CEE_NEWOBJ: {
1734                         MonoMethod *m;
1735                         MonoMethodSignature *csignature;
1736                         guint32 vt_stack_used = 0;
1737                         guint32 vt_res_size = 0;
1738
1739                         td.ip++;
1740                         token = read32 (td.ip);
1741                         td.ip += 4;
1742
1743                         if (method->wrapper_type != MONO_WRAPPER_NONE)
1744                                 m = (MonoMethod *)mono_method_get_wrapper_data (method, token);
1745                         else
1746                                 m = mono_get_method_full (image, token, NULL, generic_context);
1747
1748                         csignature = mono_method_signature (m);
1749                         klass = m->klass;
1750                         td.sp -= csignature->param_count;
1751                         ADD_CODE(&td, MINT_NEWOBJ);
1752                         ADD_CODE(&td, get_data_item_index (&td, mono_interp_get_runtime_method (domain, m, &error)));
1753                         mono_error_cleanup (&error); /* FIXME: don't swallow the error */
1754
1755                         if (mint_type (&klass->byval_arg) == MINT_TYPE_VT) {
1756                                 vt_res_size = mono_class_value_size (klass, NULL);
1757                                 PUSH_VT (&td, vt_res_size);
1758                         }
1759                         for (i = 0; i < csignature->param_count; ++i) {
1760                                 int mt = mint_type(csignature->params [i]);
1761                                 if (mt == MINT_TYPE_VT) {
1762                                         MonoClass *k = mono_class_from_mono_type (csignature->params [i]);
1763                                         gint32 size = mono_class_value_size (k, NULL);
1764                                         size = (size + 7) & ~7;
1765                                         vt_stack_used += size;
1766                                 }
1767                         }
1768                         if (vt_stack_used != 0 || vt_res_size != 0) {
1769                                 ADD_CODE(&td, MINT_VTRESULT);
1770                                 ADD_CODE(&td, vt_res_size);
1771                                 WRITE32(&td, &vt_stack_used);
1772                                 td.vt_sp -= vt_stack_used;
1773                         }
1774                         PUSH_TYPE (&td, stack_type [mint_type (&klass->byval_arg)], klass);
1775                         break;
1776                 }
1777                 case CEE_CASTCLASS:
1778                         CHECK_STACK (&td, 1);
1779                         token = read32 (td.ip + 1);
1780                         klass = mono_class_get_full (image, token, generic_context);
1781                         ADD_CODE(&td, MINT_CASTCLASS);
1782                         ADD_CODE(&td, get_data_item_index (&td, klass));
1783                         td.sp [-1].klass = klass;
1784                         td.ip += 5;
1785                         break;
1786                 case CEE_ISINST:
1787                         CHECK_STACK (&td, 1);
1788                         token = read32 (td.ip + 1);
1789                         klass = mono_class_get_full (image, token, generic_context);
1790                         ADD_CODE(&td, MINT_ISINST);
1791                         ADD_CODE(&td, get_data_item_index (&td, klass));
1792                         td.ip += 5;
1793                         break;
1794                 case CEE_CONV_R_UN:
1795                         switch (td.sp [-1].type) {
1796                         case STACK_TYPE_R8:
1797                                 break;
1798                         case STACK_TYPE_I8:
1799                                 ADD_CODE(&td, MINT_CONV_R_UN_I8);
1800                                 break;
1801                         case STACK_TYPE_I4:
1802                                 ADD_CODE(&td, MINT_CONV_R_UN_I4);
1803                                 break;
1804                         default:
1805                                 g_assert_not_reached ();
1806                         }
1807                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_R8);
1808                         ++td.ip;
1809                         break;
1810                 case CEE_UNBOX:
1811                         CHECK_STACK (&td, 1);
1812                         token = read32 (td.ip + 1);
1813
1814                         if (method->wrapper_type != MONO_WRAPPER_NONE)
1815                                 klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
1816                         else
1817                                 klass = mono_class_get_full (image, token, generic_context);
1818
1819                         if (mono_class_is_nullable (klass)) {
1820                                 g_error ("cee_unbox: implement Nullable");
1821                         }
1822
1823                         ADD_CODE(&td, MINT_UNBOX);
1824                         ADD_CODE(&td, get_data_item_index (&td, klass));
1825                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_MP);
1826                         td.ip += 5;
1827                         break;
1828                 case CEE_UNBOX_ANY:
1829                         CHECK_STACK (&td, 1);
1830                         token = read32 (td.ip + 1);
1831
1832                         g_assert (method->wrapper_type == MONO_WRAPPER_NONE);
1833                         klass = mono_class_get_full (image, token, generic_context);
1834
1835                         if (mini_type_is_reference (&klass->byval_arg)) {
1836                                 g_error ("unbox_any: generic class is reference type");
1837                         } else if (mono_class_is_nullable (klass)) {
1838                                 MonoMethod *target_method = mono_class_get_method_from_name (klass, "Unbox", 1);
1839                                 /* td.ip is incremented by interp_transform_call */
1840                                 interp_transform_call (&td, method, target_method, domain, generic_context, is_bb_start, body_start_offset);
1841                         } else {
1842                                 int mt = mint_type (&klass->byval_arg);
1843                                 ADD_CODE (&td, MINT_UNBOX);
1844                                 ADD_CODE (&td, get_data_item_index (&td, klass));
1845                                 SET_TYPE (td.sp - 1, stack_type [mt], klass);
1846                                 if (mt == MINT_TYPE_VT) {
1847                                         int size = mono_class_value_size (klass, NULL);
1848                                         PUSH_VT (&td, size);
1849                                 }
1850                                 td.ip += 5;
1851                         }
1852
1853                         break;
1854                 case CEE_THROW:
1855                         CHECK_STACK (&td, 1);
1856                         SIMPLE_OP (td, MINT_THROW);
1857                         --td.sp;
1858                         generating_code = 0;
1859                         break;
1860                 case CEE_LDFLDA:
1861                         CHECK_STACK (&td, 1);
1862                         token = read32 (td.ip + 1);
1863                         field = mono_field_from_token (image, token, &klass, generic_context);
1864                         mono_class_init (klass);
1865                         mt = mint_type(field->type);
1866                         ADD_CODE(&td, MINT_LDFLDA);
1867                         ADD_CODE(&td, klass->valuetype ? field->offset - sizeof(MonoObject) : field->offset);
1868                         td.ip += 5;
1869                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_MP);
1870                         break;
1871                 case CEE_LDFLD: {
1872                         CHECK_STACK (&td, 1);
1873                         token = read32 (td.ip + 1);
1874                         field = mono_field_from_token (image, token, &klass, generic_context);
1875                         mono_class_init (klass);
1876
1877                         MonoClass *field_klass = mono_class_from_mono_type (field->type);
1878                         mt = mint_type (&field_klass->byval_arg);
1879                         if (klass->marshalbyref) {
1880                                 ADD_CODE(&td, mt == MINT_TYPE_VT ? MINT_LDRMFLD_VT :  MINT_LDRMFLD);
1881                                 ADD_CODE(&td, get_data_item_index (&td, field));
1882                         } else  {
1883                                 ADD_CODE(&td, MINT_LDFLD_I1 + mt - MINT_TYPE_I1);
1884                                 ADD_CODE(&td, klass->valuetype ? field->offset - sizeof(MonoObject) : field->offset);
1885                         }
1886                         if (mt == MINT_TYPE_VT) {
1887                                 int size = mono_class_value_size (field_klass, NULL);
1888                                 PUSH_VT(&td, size);
1889                                 WRITE32(&td, &size);
1890                         }
1891                         if (td.sp [-1].type == STACK_TYPE_VT) {
1892                                 int size = mono_class_value_size (klass, NULL);
1893                                 size = (size + 7) & ~7;
1894                                 td.vt_sp -= size;
1895                         }
1896                         td.ip += 5;
1897                         SET_TYPE(td.sp - 1, stack_type [mt], field_klass);
1898                         break;
1899                 }
1900                 case CEE_STFLD:
1901                         CHECK_STACK (&td, 2);
1902                         token = read32 (td.ip + 1);
1903                         field = mono_field_from_token (image, token, &klass, generic_context);
1904                         mono_class_init (klass);
1905                         mt = mint_type(field->type);
1906                         if (klass->marshalbyref) {
1907                                 ADD_CODE(&td, mt == MINT_TYPE_VT ? MINT_STRMFLD_VT : MINT_STRMFLD);
1908                                 ADD_CODE(&td, get_data_item_index (&td, field));
1909                         } else  {
1910                                 ADD_CODE(&td, MINT_STFLD_I1 + mt - MINT_TYPE_I1);
1911                                 ADD_CODE(&td, klass->valuetype ? field->offset - sizeof(MonoObject) : field->offset);
1912                         }
1913                         if (mt == MINT_TYPE_VT) {
1914                                 MonoClass *klass = mono_class_from_mono_type (field->type);
1915                                 int size = mono_class_value_size (klass, NULL);
1916                                 POP_VT(&td, size);
1917                                 WRITE32(&td, &size);
1918                         }
1919                         td.ip += 5;
1920                         td.sp -= 2;
1921                         break;
1922                 case CEE_LDSFLDA:
1923                         token = read32 (td.ip + 1);
1924                         field = mono_field_from_token (image, token, &klass, generic_context);
1925                         ADD_CODE(&td, MINT_LDSFLDA);
1926                         ADD_CODE(&td, get_data_item_index (&td, field));
1927                         td.ip += 5;
1928                         PUSH_SIMPLE_TYPE(&td, STACK_TYPE_MP);
1929                         break;
1930                 case CEE_LDSFLD:
1931                         token = read32 (td.ip + 1);
1932                         field = mono_field_from_token (image, token, &klass, generic_context);
1933                         mt = mint_type(field->type);
1934                         ADD_CODE(&td, mt == MINT_TYPE_VT ? MINT_LDSFLD_VT : MINT_LDSFLD);
1935                         ADD_CODE(&td, get_data_item_index (&td, field));
1936                         klass = NULL;
1937                         if (mt == MINT_TYPE_VT) {
1938                                 g_error ("data.klass");
1939                                 int size = mono_class_value_size (field->type->data.klass, NULL);
1940                                 PUSH_VT(&td, size);
1941                                 WRITE32(&td, &size);
1942                                 klass = field->type->data.klass;
1943                         } else {
1944                                 if (mt == MINT_TYPE_O)
1945                                         klass = mono_class_from_mono_type (field->type);
1946                                 if (!domain->special_static_fields || !g_hash_table_lookup (domain->special_static_fields, field)) {
1947                                         if (mt == MINT_TYPE_O)
1948                                                 td.new_ip [-2] = MINT_LDSFLD_O;
1949                                         else if (mt == MINT_TYPE_I4)
1950                                                 td.new_ip [-2] = MINT_LDSFLD_I4;
1951                                 }
1952                                 ADD_CODE(&td, get_data_item_index (&td, mono_class_vtable (domain, field->parent)));
1953                         }
1954                         td.ip += 5;
1955                         PUSH_TYPE(&td, stack_type [mt], klass);
1956                         break;
1957                 case CEE_STSFLD:
1958                         CHECK_STACK (&td, 1);
1959                         token = read32 (td.ip + 1);
1960                         field = mono_field_from_token (image, token, &klass, generic_context);
1961                         mt = mint_type(field->type);
1962                         ADD_CODE(&td, mt == MINT_TYPE_VT ? MINT_STSFLD_VT : MINT_STSFLD);
1963                         ADD_CODE(&td, get_data_item_index (&td, field));
1964                         if (mt == MINT_TYPE_VT) {
1965                                 g_error ("data.klass");
1966                                 int size = mono_class_value_size (field->type->data.klass, NULL);
1967                                 POP_VT(&td, size);
1968                                 WRITE32(&td, &size);
1969                         }
1970                         td.ip += 5;
1971                         --td.sp;
1972                         break;
1973                 case CEE_STOBJ: {
1974                         int size;
1975                         token = read32 (td.ip + 1);
1976
1977                         if (method->wrapper_type != MONO_WRAPPER_NONE)
1978                                 klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
1979                         else
1980                                 klass = mono_class_get_full (image, token, generic_context);
1981
1982                         ADD_CODE(&td, td.sp [-1].type == STACK_TYPE_VT ? MINT_STOBJ_VT : MINT_STOBJ);
1983                         ADD_CODE(&td, get_data_item_index (&td, klass));
1984                         if (td.sp [-1].type == STACK_TYPE_VT) {
1985                                 size = mono_class_value_size (klass, NULL);
1986                                 size = (size + 7) & ~7;
1987                                 td.vt_sp -= size;
1988                         }
1989                         td.ip += 5;
1990                         td.sp -= 2;
1991                         break;
1992                 }
1993                 case CEE_CONV_OVF_I_UN:
1994                         CHECK_STACK (&td, 1);
1995                         switch (td.sp [-1].type) {
1996                         case STACK_TYPE_R8:
1997 #if SIZEOF_VOID_P == 8
1998                                 ADD_CODE(&td, MINT_CONV_OVF_I8_UN_R8);
1999 #else
2000                                 ADD_CODE(&td, MINT_CONV_OVF_I4_UN_R8);
2001 #endif
2002                                 break;
2003                         case STACK_TYPE_I8:
2004                                 /*FIX*/
2005                                 break;
2006                         case STACK_TYPE_I4:
2007 #if SIZEOF_VOID_P == 8
2008                                 ADD_CODE(&td, MINT_CONV_I8_U4);
2009 #endif
2010                                 break;
2011                         default:
2012                                 g_assert_not_reached ();
2013                                 break;
2014                         }
2015                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I8);
2016                         ++td.ip;
2017                         break;
2018                 case CEE_CONV_OVF_I8_UN:
2019                         CHECK_STACK (&td, 1);
2020                         switch (td.sp [-1].type) {
2021                         case STACK_TYPE_R8:
2022                                 ADD_CODE(&td, MINT_CONV_OVF_I8_UN_R8);
2023                                 break;
2024                         case STACK_TYPE_I8:
2025                                 break;
2026                         case STACK_TYPE_I4:
2027                                 ADD_CODE(&td, MINT_CONV_I8_U4);
2028                                 break;
2029                         default:
2030                                 g_assert_not_reached ();
2031                                 break;
2032                         }
2033                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I8);
2034                         ++td.ip;
2035                         break;
2036                 case CEE_BOX: {
2037                         int size;
2038                         CHECK_STACK (&td, 1);
2039                         token = read32 (td.ip + 1);
2040                         if (method->wrapper_type != MONO_WRAPPER_NONE)
2041                                 klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
2042                         else
2043                                 klass = mono_class_get_full (image, token, generic_context);
2044                         g_assert (klass->valuetype);
2045
2046                         if (mono_class_is_nullable (klass)) {
2047                                 MonoMethod *target_method = mono_class_get_method_from_name (klass, "Box", 1);
2048                                 /* td.ip is incremented by interp_transform_call */
2049                                 interp_transform_call (&td, method, target_method, domain, generic_context, is_bb_start, body_start_offset);
2050                         } else {
2051                                 if (klass->byval_arg.type == MONO_TYPE_VALUETYPE && !klass->enumtype) {
2052                                         size = mono_class_value_size (klass, NULL);
2053                                         size = (size + 7) & ~7;
2054                                         td.vt_sp -= size;
2055                                 }
2056                                 ADD_CODE(&td, MINT_BOX);
2057                                 ADD_CODE(&td, get_data_item_index (&td, klass));
2058                                 SET_TYPE(td.sp - 1, STACK_TYPE_O, klass);
2059                                 td.ip += 5;
2060                         }
2061
2062                         break;
2063                 }
2064                 case CEE_NEWARR:
2065                         CHECK_STACK (&td, 1);
2066                         token = read32 (td.ip + 1);
2067
2068                         if (method->wrapper_type != MONO_WRAPPER_NONE)
2069                                 klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
2070                         else
2071                                 klass = mono_class_get_full (image, token, generic_context);
2072
2073                         ADD_CODE(&td, MINT_NEWARR);
2074                         ADD_CODE(&td, get_data_item_index (&td, klass));
2075                         SET_TYPE(td.sp - 1, STACK_TYPE_O, klass);
2076                         td.ip += 5;
2077                         break;
2078                 case CEE_LDLEN:
2079                         CHECK_STACK (&td, 1);
2080                         SIMPLE_OP (td, MINT_LDLEN);
2081                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I);
2082                         break;
2083                 case CEE_LDELEMA:
2084                         CHECK_STACK (&td, 2);
2085                         ENSURE_I4 (&td, 1);
2086                         token = read32 (td.ip + 1);
2087
2088                         if (method->wrapper_type != MONO_WRAPPER_NONE)
2089                                 klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
2090                         else
2091                                 klass = mono_class_get_full (image, token, generic_context);
2092
2093                         ADD_CODE(&td, MINT_LDELEMA);
2094                         ADD_CODE(&td, get_data_item_index (&td, klass));
2095                         td.ip += 5;
2096                         --td.sp;
2097                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_MP);
2098                         break;
2099                 case CEE_LDELEM_I1:
2100                         CHECK_STACK (&td, 2);
2101                         ENSURE_I4 (&td, 1);
2102                         SIMPLE_OP (td, MINT_LDELEM_I1);
2103                         --td.sp;
2104                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2105                         break;
2106                 case CEE_LDELEM_U1:
2107                         CHECK_STACK (&td, 2);
2108                         ENSURE_I4 (&td, 1);
2109                         SIMPLE_OP (td, MINT_LDELEM_U1);
2110                         --td.sp;
2111                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2112                         break;
2113                 case CEE_LDELEM_I2:
2114                         CHECK_STACK (&td, 2);
2115                         ENSURE_I4 (&td, 1);
2116                         SIMPLE_OP (td, MINT_LDELEM_I2);
2117                         --td.sp;
2118                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2119                         break;
2120                 case CEE_LDELEM_U2:
2121                         CHECK_STACK (&td, 2);
2122                         ENSURE_I4 (&td, 1);
2123                         SIMPLE_OP (td, MINT_LDELEM_U2);
2124                         --td.sp;
2125                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2126                         break;
2127                 case CEE_LDELEM_I4:
2128                         CHECK_STACK (&td, 2);
2129                         ENSURE_I4 (&td, 1);
2130                         SIMPLE_OP (td, MINT_LDELEM_I4);
2131                         --td.sp;
2132                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2133                         break;
2134                 case CEE_LDELEM_U4:
2135                         CHECK_STACK (&td, 2);
2136                         ENSURE_I4 (&td, 1);
2137                         SIMPLE_OP (td, MINT_LDELEM_U4);
2138                         --td.sp;
2139                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2140                         break;
2141                 case CEE_LDELEM_I8:
2142                         CHECK_STACK (&td, 2);
2143                         ENSURE_I4 (&td, 1);
2144                         SIMPLE_OP (td, MINT_LDELEM_I8);
2145                         --td.sp;
2146                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I8);
2147                         break;
2148                 case CEE_LDELEM_I:
2149                         CHECK_STACK (&td, 2);
2150                         ENSURE_I4 (&td, 1);
2151                         SIMPLE_OP (td, MINT_LDELEM_I);
2152                         --td.sp;
2153                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I);
2154                         break;
2155                 case CEE_LDELEM_R4:
2156                         CHECK_STACK (&td, 2);
2157                         ENSURE_I4 (&td, 1);
2158                         SIMPLE_OP (td, MINT_LDELEM_R4);
2159                         --td.sp;
2160                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_R8);
2161                         break;
2162                 case CEE_LDELEM_R8:
2163                         CHECK_STACK (&td, 2);
2164                         ENSURE_I4 (&td, 1);
2165                         SIMPLE_OP (td, MINT_LDELEM_R8);
2166                         --td.sp;
2167                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_R8);
2168                         break;
2169                 case CEE_LDELEM_REF:
2170                         CHECK_STACK (&td, 2);
2171                         ENSURE_I4 (&td, 1);
2172                         SIMPLE_OP (td, MINT_LDELEM_REF);
2173                         --td.sp;
2174                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_O);
2175                         break;
2176                 case CEE_LDELEM:
2177                         CHECK_STACK (&td, 2);
2178                         token = read32 (td.ip + 1);
2179                         klass = mono_class_get_full (image, token, generic_context);
2180                         switch (mint_type (&klass->byval_arg)) {
2181                                 case MINT_TYPE_I4:
2182                                         ENSURE_I4 (&td, 1);
2183                                         SIMPLE_OP (td, MINT_LDELEM_I4);
2184                                         --td.sp;
2185                                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2186                                         break;
2187                                 default: {
2188                                         GString *res = g_string_new ("");
2189                                         mono_type_get_desc (res, &klass->byval_arg, TRUE);
2190                                         g_print ("LDELEM: %s -> %d (%s)\n", klass->name, mint_type (&klass->byval_arg), res->str);
2191                                         g_string_free (res, TRUE);
2192                                         g_assert (0);
2193                                         break;
2194                                 }
2195                         }
2196                         td.ip += 4;
2197                         break;
2198                 case CEE_STELEM_I:
2199                         CHECK_STACK (&td, 3);
2200                         ENSURE_I4 (&td, 2);
2201                         SIMPLE_OP (td, MINT_STELEM_I);
2202                         td.sp -= 3;
2203                         break;
2204                 case CEE_STELEM_I1:
2205                         CHECK_STACK (&td, 3);
2206                         ENSURE_I4 (&td, 2);
2207                         SIMPLE_OP (td, MINT_STELEM_I1);
2208                         td.sp -= 3;
2209                         break;
2210                 case CEE_STELEM_I2:
2211                         CHECK_STACK (&td, 3);
2212                         ENSURE_I4 (&td, 2);
2213                         SIMPLE_OP (td, MINT_STELEM_I2);
2214                         td.sp -= 3;
2215                         break;
2216                 case CEE_STELEM_I4:
2217                         CHECK_STACK (&td, 3);
2218                         ENSURE_I4 (&td, 2);
2219                         SIMPLE_OP (td, MINT_STELEM_I4);
2220                         td.sp -= 3;
2221                         break;
2222                 case CEE_STELEM_I8:
2223                         CHECK_STACK (&td, 3);
2224                         ENSURE_I4 (&td, 2);
2225                         SIMPLE_OP (td, MINT_STELEM_I8);
2226                         td.sp -= 3;
2227                         break;
2228                 case CEE_STELEM_R4:
2229                         CHECK_STACK (&td, 3);
2230                         ENSURE_I4 (&td, 2);
2231                         SIMPLE_OP (td, MINT_STELEM_R4);
2232                         td.sp -= 3;
2233                         break;
2234                 case CEE_STELEM_R8:
2235                         CHECK_STACK (&td, 3);
2236                         ENSURE_I4 (&td, 2);
2237                         SIMPLE_OP (td, MINT_STELEM_R8);
2238                         td.sp -= 3;
2239                         break;
2240                 case CEE_STELEM_REF:
2241                         CHECK_STACK (&td, 3);
2242                         ENSURE_I4 (&td, 2);
2243                         SIMPLE_OP (td, MINT_STELEM_REF);
2244                         td.sp -= 3;
2245                         break;
2246                 case CEE_STELEM:
2247                         CHECK_STACK (&td, 3);
2248                         ENSURE_I4 (&td, 2);
2249                         token = read32 (td.ip + 1);
2250                         klass = mono_class_get_full (image, token, generic_context);
2251                         switch (mint_type (&klass->byval_arg)) {
2252                                 case MINT_TYPE_I4:
2253                                         SIMPLE_OP (td, MINT_STELEM_I4);
2254                                         break;
2255                                 default: {
2256                                         GString *res = g_string_new ("");
2257                                         mono_type_get_desc (res, &klass->byval_arg, TRUE);
2258                                         g_print ("STELEM: %s -> %d (%s)\n", klass->name, mint_type (&klass->byval_arg), res->str);
2259                                         g_string_free (res, TRUE);
2260                                         g_assert (0);
2261                                         break;
2262                                 }
2263                         }
2264                         td.ip += 4;
2265                         td.sp -= 3;
2266                         break;
2267 #if 0
2268                 case CEE_CONV_OVF_U1:
2269
2270                 case CEE_CONV_OVF_I8:
2271
2272 #if SIZEOF_VOID_P == 8
2273                 case CEE_CONV_OVF_U:
2274 #endif
2275                 case CEE_REFANYVAL: ves_abort(); break;
2276 #endif
2277                 case CEE_CKFINITE:
2278                         CHECK_STACK (&td, 1);
2279                         SIMPLE_OP (td, MINT_CKFINITE);
2280                         break;
2281                 case CEE_CONV_OVF_I1:
2282                 case CEE_CONV_OVF_I1_UN:
2283                         CHECK_STACK (&td, 1);
2284                         switch (td.sp [-1].type) {
2285                         case STACK_TYPE_R8:
2286                                 ADD_CODE(&td, MINT_CONV_OVF_I1_R8);
2287                                 break;
2288                         case STACK_TYPE_I4:
2289                                 ADD_CODE(&td, MINT_CONV_OVF_I1_I4);
2290                                 break;
2291                         case STACK_TYPE_I8:
2292                                 ADD_CODE(&td, MINT_CONV_OVF_I1_I8);
2293                                 break;
2294                         default:
2295                                 g_assert_not_reached ();
2296                         }
2297                         ++td.ip;
2298                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2299                         break;
2300                 case CEE_CONV_OVF_U1:
2301                 case CEE_CONV_OVF_U1_UN:
2302                         CHECK_STACK (&td, 1);
2303                         switch (td.sp [-1].type) {
2304                         case STACK_TYPE_R8:
2305                                 ADD_CODE(&td, MINT_CONV_OVF_U1_R8);
2306                                 break;
2307                         case STACK_TYPE_I4:
2308                                 ADD_CODE(&td, MINT_CONV_OVF_U1_I4);
2309                                 break;
2310                         case STACK_TYPE_I8:
2311                                 ADD_CODE(&td, MINT_CONV_OVF_U1_I8);
2312                                 break;
2313                         default:
2314                                 g_assert_not_reached ();
2315                         }
2316                         ++td.ip;
2317                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2318                         break;
2319                 case CEE_CONV_OVF_I2:
2320                 case CEE_CONV_OVF_I2_UN:
2321                         CHECK_STACK (&td, 1);
2322                         switch (td.sp [-1].type) {
2323                         case STACK_TYPE_R8:
2324                                 ADD_CODE(&td, MINT_CONV_OVF_I2_R8);
2325                                 break;
2326                         case STACK_TYPE_I4:
2327                                 ADD_CODE(&td, MINT_CONV_OVF_I2_I4);
2328                                 break;
2329                         case STACK_TYPE_I8:
2330                                 ADD_CODE(&td, MINT_CONV_OVF_I2_I8);
2331                                 break;
2332                         default:
2333                                 g_assert_not_reached ();
2334                         }
2335                         ++td.ip;
2336                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2337                         break;
2338                 case CEE_CONV_OVF_U2_UN:
2339                 case CEE_CONV_OVF_U2:
2340                         CHECK_STACK (&td, 1);
2341                         switch (td.sp [-1].type) {
2342                         case STACK_TYPE_R8:
2343                                 ADD_CODE(&td, MINT_CONV_OVF_U2_R8);
2344                                 break;
2345                         case STACK_TYPE_I4:
2346                                 ADD_CODE(&td, MINT_CONV_OVF_U2_I4);
2347                                 break;
2348                         case STACK_TYPE_I8:
2349                                 ADD_CODE(&td, MINT_CONV_OVF_U2_I8);
2350                                 break;
2351                         default:
2352                                 g_assert_not_reached ();
2353                         }
2354                         ++td.ip;
2355                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2356                         break;
2357 #if SIZEOF_VOID_P == 4
2358                 case CEE_CONV_OVF_I:
2359 #endif
2360                 case CEE_CONV_OVF_I4:
2361                 case CEE_CONV_OVF_I4_UN:
2362                         CHECK_STACK (&td, 1);
2363                         switch (td.sp [-1].type) {
2364                         case STACK_TYPE_R8:
2365                                 ADD_CODE(&td, MINT_CONV_OVF_I4_R8);
2366                                 break;
2367                         case STACK_TYPE_I4:
2368                                 if (*td.ip == CEE_CONV_OVF_I4_UN)
2369                                         ADD_CODE(&td, MINT_CONV_OVF_I4_U4);
2370                                 break;
2371                         case STACK_TYPE_I8:
2372                                 ADD_CODE(&td, MINT_CONV_OVF_I4_I8);
2373                                 break;
2374                         default:
2375                                 g_assert_not_reached ();
2376                         }
2377                         ++td.ip;
2378                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2379                         break;
2380 #if SIZEOF_VOID_P == 4
2381                 case CEE_CONV_OVF_U:
2382 #endif
2383                 case CEE_CONV_OVF_U4:
2384                 case CEE_CONV_OVF_U4_UN:
2385                         CHECK_STACK (&td, 1);
2386                         switch (td.sp [-1].type) {
2387                         case STACK_TYPE_R8:
2388                                 ADD_CODE(&td, MINT_CONV_OVF_U4_R8);
2389                                 break;
2390                         case STACK_TYPE_I4:
2391                                 if (*td.ip != CEE_CONV_OVF_U4_UN)
2392                                         ADD_CODE(&td, MINT_CONV_OVF_U4_I4);
2393                                 break;
2394                         case STACK_TYPE_I8:
2395                                 ADD_CODE(&td, MINT_CONV_OVF_U4_I8);
2396                                 break;
2397                         default:
2398                                 g_assert_not_reached ();
2399                         }
2400                         ++td.ip;
2401                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2402                         break;
2403 #if SIZEOF_VOID_P == 8
2404                 case CEE_CONV_OVF_I:
2405 #endif
2406                 case CEE_CONV_OVF_I8:
2407                         CHECK_STACK (&td, 1);
2408                         switch (td.sp [-1].type) {
2409                         case STACK_TYPE_R8:
2410                                 ADD_CODE(&td, MINT_CONV_OVF_I8_R8);
2411                                 break;
2412                         case STACK_TYPE_I4:
2413                                 ADD_CODE(&td, MINT_CONV_I8_I4);
2414                                 break;
2415                         case STACK_TYPE_I8:
2416                                 break;
2417                         default:
2418                                 g_assert_not_reached ();
2419                         }
2420                         ++td.ip;
2421                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I8);
2422                         break;
2423 #if SIZEOF_VOID_P == 8
2424                 case CEE_CONV_OVF_U:
2425 #endif
2426                 case CEE_CONV_OVF_U8:
2427                         CHECK_STACK (&td, 1);
2428                         switch (td.sp [-1].type) {
2429                         case STACK_TYPE_R8:
2430                                 ADD_CODE(&td, MINT_CONV_OVF_U8_R8);
2431                                 break;
2432                         case STACK_TYPE_I4:
2433                                 ADD_CODE(&td, MINT_CONV_OVF_U8_I4);
2434                                 break;
2435                         case STACK_TYPE_I8:
2436                                 break;
2437                         default:
2438                                 g_assert_not_reached ();
2439                         }
2440                         ++td.ip;
2441                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I8);
2442                         break;
2443                 case CEE_LDTOKEN: {
2444                         int size;
2445                         gpointer handle;
2446                         token = read32 (td.ip + 1);
2447                         handle = mono_ldtoken (image, token, &klass, generic_context);
2448                         mt = mint_type(&klass->byval_arg);
2449                         g_assert (mt == MINT_TYPE_VT);
2450                         size = mono_class_value_size (klass, NULL);
2451                         g_assert (size == sizeof(gpointer));
2452                         PUSH_VT(&td, sizeof(gpointer));
2453                         ADD_CODE(&td, MINT_LDTOKEN);
2454                         ADD_CODE(&td, get_data_item_index (&td, handle));
2455                         PUSH_SIMPLE_TYPE(&td, stack_type [mt]);
2456                         td.ip += 5;
2457                         break;
2458                 }
2459                 case CEE_ADD_OVF:
2460                         binary_arith_op(&td, MINT_ADD_OVF_I4);
2461                         ++td.ip;
2462                         break;
2463                 case CEE_ADD_OVF_UN:
2464                         binary_arith_op(&td, MINT_ADD_OVF_UN_I4);
2465                         ++td.ip;
2466                         break;
2467                 case CEE_MUL_OVF:
2468                         binary_arith_op(&td, MINT_MUL_OVF_I4);
2469                         ++td.ip;
2470                         break;
2471                 case CEE_MUL_OVF_UN:
2472                         binary_arith_op(&td, MINT_MUL_OVF_UN_I4);
2473                         ++td.ip;
2474                         break;
2475                 case CEE_SUB_OVF:
2476                         binary_arith_op(&td, MINT_SUB_OVF_I4);
2477                         ++td.ip;
2478                         break;
2479                 case CEE_SUB_OVF_UN:
2480                         binary_arith_op(&td, MINT_SUB_OVF_UN_I4);
2481                         ++td.ip;
2482                         break;
2483                 case CEE_ENDFINALLY:
2484                         SIMPLE_OP (td, MINT_ENDFINALLY);
2485                         generating_code = 0;
2486                         break;
2487                 case CEE_LEAVE:
2488                         td.sp = td.stack;
2489                         handle_branch (&td, MINT_LEAVE_S, MINT_LEAVE, 5 + read32 (td.ip + 1));
2490                         td.ip += 5;
2491                         generating_code = 0;
2492                         break;
2493                 case CEE_LEAVE_S:
2494                         td.sp = td.stack;
2495                         handle_branch (&td, MINT_LEAVE_S, MINT_LEAVE, 2 + (gint8)td.ip [1]);
2496                         td.ip += 2;
2497                         generating_code = 0;
2498                         break;
2499                 case CEE_UNUSED41:
2500                         ++td.ip;
2501                         switch (*td.ip) {
2502                                 case CEE_MONO_CALLI_EXTRA_ARG:
2503                                         /* Same as CEE_CALLI, llvm specific */
2504                                         interp_transform_call (&td, method, NULL, domain, generic_context, is_bb_start, body_start_offset);
2505                                         break;
2506                                 case CEE_MONO_ICALL: {
2507                                         guint32 token;
2508                                         gpointer func;
2509                                         MonoJitICallInfo *info;
2510
2511                                         token = read32 (td.ip + 1);
2512                                         td.ip += 5;
2513                                         func = mono_method_get_wrapper_data (method, token);
2514                                         info = mono_find_jit_icall_by_addr (func);
2515                                         g_assert (info);
2516
2517                                         CHECK_STACK (&td, info->sig->param_count);
2518                                         switch (info->sig->param_count) {
2519                                         case 0:
2520                                                 if (MONO_TYPE_IS_VOID (info->sig->ret))
2521                                                         ADD_CODE (&td,MINT_ICALL_V_V);
2522                                                 else
2523                                                         ADD_CODE (&td, MINT_ICALL_V_P);
2524                                                 break;
2525                                         case 1:
2526                                                 if (MONO_TYPE_IS_VOID (info->sig->ret))
2527                                                         ADD_CODE (&td,MINT_ICALL_P_V);
2528                                                 else
2529                                                         ADD_CODE (&td,MINT_ICALL_P_P);
2530                                                 break;
2531                                         case 2:
2532                                                 if (MONO_TYPE_IS_VOID (info->sig->ret)) {
2533                                                         if (info->sig->params [1]->type == MONO_TYPE_I4)
2534                                                                 ADD_CODE (&td,MINT_ICALL_PI_V);
2535                                                         else
2536                                                                 ADD_CODE (&td,MINT_ICALL_PP_V);
2537                                                 } else {
2538                                                         if (info->sig->params [1]->type == MONO_TYPE_I4)
2539                                                                 ADD_CODE (&td,MINT_ICALL_PI_P);
2540                                                         else
2541                                                                 ADD_CODE (&td,MINT_ICALL_PP_P);
2542                                                 }
2543                                                 break;
2544                                         case 3:
2545                                                 g_assert (MONO_TYPE_IS_VOID (info->sig->ret));
2546                                                 if (info->sig->params [2]->type == MONO_TYPE_I4)
2547                                                         ADD_CODE (&td,MINT_ICALL_PPI_V);
2548                                                 else
2549                                                         ADD_CODE (&td,MINT_ICALL_PPP_V);
2550                                                 break;
2551                                         default:
2552                                                 g_assert_not_reached ();
2553                                         }
2554
2555                                         if (func == mono_ftnptr_to_delegate) {
2556                                                 g_error ("TODO: ?");
2557                                                 func = mono_interp_ftnptr_to_delegate;
2558                                         }
2559                                         ADD_CODE(&td, get_data_item_index (&td, func));
2560                                         td.sp -= info->sig->param_count;
2561
2562                                         if (!MONO_TYPE_IS_VOID (info->sig->ret)) {
2563                                                 td.sp ++;
2564                                                 SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I);
2565                                         }
2566                                         break;
2567                                 }
2568                         case CEE_MONO_VTADDR: {
2569                                 int size;
2570                                 CHECK_STACK (&td, 1);
2571                                 if (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE)
2572                                         size = mono_class_native_size(td.sp [-1].klass, NULL);
2573                                 else
2574                                         size = mono_class_value_size(td.sp [-1].klass, NULL);
2575                                 size = (size + 7) & ~7;
2576                                 ADD_CODE(&td, MINT_VTRESULT);
2577                                 ADD_CODE(&td, 0);
2578                                 WRITE32(&td, &size);
2579                                 td.vt_sp -= size;
2580                                 ++td.ip;
2581                                 SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_MP);
2582                                 break;
2583                         }
2584                         case CEE_MONO_LDPTR:
2585                         case CEE_MONO_CLASSCONST:
2586                                 token = read32 (td.ip + 1);
2587                                 td.ip += 5;
2588                                 ADD_CODE(&td, MINT_MONO_LDPTR);
2589                                 ADD_CODE(&td, get_data_item_index (&td, mono_method_get_wrapper_data (method, token)));
2590                                 td.sp [0].type = STACK_TYPE_I;
2591                                 ++td.sp;
2592                                 break;
2593                         case CEE_MONO_OBJADDR:
2594                                 CHECK_STACK (&td, 1);
2595                                 ++td.ip;
2596                                 td.sp[-1].type = STACK_TYPE_MP;
2597                                 /* do nothing? */
2598                                 break;
2599                         case CEE_MONO_NEWOBJ:
2600                                 token = read32 (td.ip + 1);
2601                                 td.ip += 5;
2602                                 ADD_CODE(&td, MINT_MONO_NEWOBJ);
2603                                 ADD_CODE(&td, get_data_item_index (&td, mono_method_get_wrapper_data (method, token)));
2604                                 td.sp [0].type = STACK_TYPE_O;
2605                                 ++td.sp;
2606                                 break;
2607                         case CEE_MONO_RETOBJ:
2608                                 CHECK_STACK (&td, 1);
2609                                 token = read32 (td.ip + 1);
2610                                 td.ip += 5;
2611                                 ADD_CODE(&td, MINT_MONO_RETOBJ);
2612                                 td.sp--;
2613
2614                                 klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
2615
2616                                 /*stackval_from_data (signature->ret, frame->retval, sp->data.vt, signature->pinvoke);*/
2617
2618                                 if (td.sp > td.stack)
2619                                         g_warning ("CEE_MONO_RETOBJ: more values on stack: %d", td.sp-td.stack);
2620                                 break;
2621                         case CEE_MONO_LDNATIVEOBJ:
2622                                 token = read32 (td.ip + 1);
2623                                 td.ip += 5;
2624                                 klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
2625                                 g_assert(klass->valuetype);
2626                                 SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_MP);
2627                                 break;
2628                         case CEE_MONO_SAVE_LMF:
2629                         case CEE_MONO_RESTORE_LMF:
2630                         case CEE_MONO_NOT_TAKEN:
2631                                 ++td.ip;
2632                                 break;
2633                         case CEE_MONO_LDPTR_INT_REQ_FLAG:
2634                                 ADD_CODE (&td, MINT_MONO_LDPTR);
2635                                 ADD_CODE (&td, get_data_item_index (&td, mono_thread_interruption_request_flag ()));
2636                                 PUSH_TYPE (&td, STACK_TYPE_MP, NULL);
2637                                 ++td.ip;
2638                                 break;
2639                         default:
2640                                 g_error ("transform.c: Unimplemented opcode: 0xF0 %02x at 0x%x\n", *td.ip, td.ip-header->code);
2641                         }
2642                         break;
2643 #if 0
2644                 case CEE_PREFIX7:
2645                 case CEE_PREFIX6:
2646                 case CEE_PREFIX5:
2647                 case CEE_PREFIX4:
2648                 case CEE_PREFIX3:
2649                 case CEE_PREFIX2:
2650                 case CEE_PREFIXREF: ves_abort(); break;
2651 #endif
2652                 /*
2653                  * Note: Exceptions thrown when executing a prefixed opcode need
2654                  * to take into account the number of prefix bytes (usually the
2655                  * throw point is just (ip - n_prefix_bytes).
2656                  */
2657                 case CEE_PREFIX1:
2658                         ++td.ip;
2659                         switch (*td.ip) {
2660 #if 0
2661                         case CEE_ARGLIST: ves_abort(); break;
2662 #endif
2663                         case CEE_CEQ:
2664                                 CHECK_STACK(&td, 2);
2665                                 if (td.sp [-1].type == STACK_TYPE_O || td.sp [-1].type == STACK_TYPE_MP)
2666                                         ADD_CODE(&td, MINT_CEQ_I4 + STACK_TYPE_I - STACK_TYPE_I4);
2667                                 else
2668                                         ADD_CODE(&td, MINT_CEQ_I4 + td.sp [-1].type - STACK_TYPE_I4);
2669                                 --td.sp;
2670                                 SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2671                                 ++td.ip;
2672                                 break;
2673                         case CEE_CGT:
2674                                 CHECK_STACK(&td, 2);
2675                                 if (td.sp [-1].type == STACK_TYPE_O || td.sp [-1].type == STACK_TYPE_MP)
2676                                         ADD_CODE(&td, MINT_CGT_I4 + STACK_TYPE_I - STACK_TYPE_I4);
2677                                 else
2678                                         ADD_CODE(&td, MINT_CGT_I4 + td.sp [-1].type - STACK_TYPE_I4);
2679                                 --td.sp;
2680                                 SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2681                                 ++td.ip;
2682                                 break;
2683                         case CEE_CGT_UN:
2684                                 CHECK_STACK(&td, 2);
2685                                 if (td.sp [-1].type == STACK_TYPE_O || td.sp [-1].type == STACK_TYPE_MP)
2686                                         ADD_CODE(&td, MINT_CGT_UN_I4 + STACK_TYPE_I - STACK_TYPE_I4);
2687                                 else
2688                                         ADD_CODE(&td, MINT_CGT_UN_I4 + td.sp [-1].type - STACK_TYPE_I4);
2689                                 --td.sp;
2690                                 SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2691                                 ++td.ip;
2692                                 break;
2693                         case CEE_CLT:
2694                                 CHECK_STACK(&td, 2);
2695                                 if (td.sp [-1].type == STACK_TYPE_O || td.sp [-1].type == STACK_TYPE_MP)
2696                                         ADD_CODE(&td, MINT_CLT_I4 + STACK_TYPE_I - STACK_TYPE_I4);
2697                                 else
2698                                         ADD_CODE(&td, MINT_CLT_I4 + td.sp [-1].type - STACK_TYPE_I4);
2699                                 --td.sp;
2700                                 SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2701                                 ++td.ip;
2702                                 break;
2703                         case CEE_CLT_UN:
2704                                 CHECK_STACK(&td, 2);
2705                                 if (td.sp [-1].type == STACK_TYPE_O || td.sp [-1].type == STACK_TYPE_MP)
2706                                         ADD_CODE(&td, MINT_CLT_UN_I4 + STACK_TYPE_I - STACK_TYPE_I4);
2707                                 else
2708                                         ADD_CODE(&td, MINT_CLT_UN_I4 + td.sp [-1].type - STACK_TYPE_I4);
2709                                 --td.sp;
2710                                 SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2711                                 ++td.ip;
2712                                 break;
2713                         case CEE_LDVIRTFTN: /* fallthrough */
2714                         case CEE_LDFTN: {
2715                                 MonoMethod *m;
2716                                 if (*td.ip == CEE_LDVIRTFTN) {
2717                                         CHECK_STACK (&td, 1);
2718                                         --td.sp;
2719                                 }
2720                                 token = read32 (td.ip + 1);
2721                                 if (method->wrapper_type != MONO_WRAPPER_NONE)
2722                                         m = (MonoMethod *)mono_method_get_wrapper_data (method, token);
2723                                 else
2724                                         m = mono_get_method_full (image, token, NULL, generic_context);
2725
2726                                 if (method->wrapper_type == MONO_WRAPPER_NONE && m->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED)
2727                                         m = mono_marshal_get_synchronized_wrapper (m);
2728
2729                                 ADD_CODE(&td, *td.ip == CEE_LDFTN ? MINT_LDFTN : MINT_LDVIRTFTN);
2730                                 ADD_CODE(&td, get_data_item_index (&td, mono_interp_get_runtime_method (domain, m, &error)));
2731                                 mono_error_cleanup (&error); /* FIXME: don't swallow the error */
2732                                 td.ip += 5;
2733                                 PUSH_SIMPLE_TYPE (&td, STACK_TYPE_F);
2734                                 break;
2735                         }
2736                         case CEE_LDARG:
2737                                 load_arg (&td, read16 (td.ip + 1));
2738                                 td.ip += 3;
2739                                 break;
2740                         case CEE_LDARGA: {
2741                                 int n = read16 (td.ip + 1);
2742                                 if (n == 0 && signature->hasthis)
2743                                         ADD_CODE(&td, MINT_LDTHISA);
2744                                 else {
2745                                         ADD_CODE(&td, MINT_LDARGA);
2746                                         ADD_CODE(&td, td.rtm->arg_offsets [n - signature->hasthis]); /* FIX for large offsets */
2747                                 }
2748                                 PUSH_SIMPLE_TYPE(&td, STACK_TYPE_MP);
2749                                 td.ip += 3;
2750                                 break;
2751                         }
2752                         case CEE_STARG:
2753                                 store_arg (&td, read16 (td.ip + 1));
2754                                 td.ip += 3;
2755                                 break;
2756                         case CEE_LDLOC:
2757                                 load_local (&td, read16 (td.ip + 1));
2758                                 td.ip += 3;
2759                                 break;
2760                         case CEE_LDLOCA:
2761                                 ADD_CODE(&td, MINT_LDLOCA_S);
2762                                 ADD_CODE(&td, td.rtm->local_offsets [read16 (td.ip + 1)]);
2763                                 PUSH_SIMPLE_TYPE(&td, STACK_TYPE_MP);
2764                                 td.ip += 3;
2765                                 break;
2766                         case CEE_STLOC:
2767                                 store_local (&td, read16 (td.ip + 1));
2768                                 td.ip += 3;
2769                                 break;
2770                         case CEE_LOCALLOC:
2771                                 CHECK_STACK (&td, 1);
2772 #if SIZEOF_VOID_P == 8
2773                                 if (td.sp [-1].type == STACK_TYPE_I8)
2774                                         ADD_CODE(&td, MINT_CONV_I4_I8);
2775 #endif
2776                                 ADD_CODE(&td, MINT_LOCALLOC);
2777                                 if (td.sp != td.stack + 1)
2778                                         g_warning("CEE_LOCALLOC: stack not empty");
2779                                 ++td.ip;
2780                                 SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_MP);
2781                                 break;
2782 #if 0
2783                         case CEE_UNUSED57: ves_abort(); break;
2784                         case CEE_ENDFILTER: ves_abort(); break;
2785 #endif
2786                         case CEE_UNALIGNED_:
2787                                 ++td.ip;
2788                                 /* FIX: should do something? */;
2789                                 break;
2790                         case CEE_VOLATILE_:
2791                                 ++td.ip;
2792                                 /* FIX: should do something? */;
2793                                 break;
2794                         case CEE_TAIL_:
2795                                 ++td.ip;
2796                                 /* FIX: should do something? */;
2797                                 break;
2798                         case CEE_INITOBJ:
2799                                 CHECK_STACK(&td, 1);
2800                                 token = read32 (td.ip + 1);
2801                                 klass = mono_class_get_full (image, token, generic_context);
2802                                 ADD_CODE(&td, MINT_INITOBJ);
2803                                 i32 = mono_class_value_size (klass, NULL);
2804                                 WRITE32(&td, &i32);
2805                                 td.ip += 5;
2806                                 --td.sp;
2807                                 break;
2808                         case CEE_CPBLK:
2809                                 CHECK_STACK(&td, 3);
2810                                 /* FIX? convert length to I8? */
2811                                 ADD_CODE(&td, MINT_CPBLK);
2812                                 td.sp -= 3;
2813                                 ++td.ip;
2814                                 break;
2815 #if 0
2816                         case CEE_CONSTRAINED_: {
2817                                 guint32 token;
2818                                 /* FIXME: implement */
2819                                 ++ip;
2820                                 token = read32 (ip);
2821                                 ip += 4;
2822                                 break;
2823                         }
2824 #endif
2825                         case CEE_INITBLK:
2826                                 CHECK_STACK(&td, 3);
2827                                 ADD_CODE(&td, MINT_INITBLK);
2828                                 td.sp -= 3;
2829                                 break;
2830 #if 0
2831                         case CEE_NO_:
2832                                 /* FIXME: implement */
2833                                 ip += 2;
2834                                 break;
2835 #endif
2836                         case CEE_RETHROW:
2837                                 SIMPLE_OP (td, MINT_RETHROW);
2838                                 generating_code = 0;
2839                                 break;
2840                         case CEE_SIZEOF: {
2841                                 gint32 size;
2842                                 token = read32 (td.ip + 1);
2843                                 td.ip += 5;
2844                                 if (mono_metadata_token_table (token) == MONO_TABLE_TYPESPEC) {
2845                                         int align;
2846                                         MonoType *type = mono_type_create_from_typespec (image, token);
2847                                         size = mono_type_size (type, &align);
2848                                 } else {
2849                                         guint32 align;
2850                                         MonoClass *szclass = mono_class_get_full (image, token, generic_context);
2851                                         mono_class_init (szclass);
2852 #if 0
2853                                         if (!szclass->valuetype)
2854                                                 THROW_EX (mono_exception_from_name (mono_defaults.corlib, "System", "InvalidProgramException"), ip - 5);
2855 #endif
2856                                         size = mono_class_value_size (szclass, &align);
2857                                 }
2858                                 ADD_CODE(&td, MINT_LDC_I4);
2859                                 WRITE32(&td, &size);
2860                                 PUSH_SIMPLE_TYPE(&td, STACK_TYPE_I4);
2861                                 break;
2862                         }
2863 #if 0
2864                         case CEE_REFANYTYPE: ves_abort(); break;
2865 #endif
2866                         default:
2867                                 g_error ("transform.c: Unimplemented opcode: 0xFE %02x (%s) at 0x%x\n", *td.ip, mono_opcode_name (256 + *td.ip), td.ip-header->code);
2868                         }
2869                         break;
2870                 default:
2871                         g_error ("transform.c: Unimplemented opcode: %02x at 0x%x\n", *td.ip, td.ip-header->code);
2872                 }
2873
2874                 if (td.new_ip - td.new_code != new_in_start_offset)
2875                         td.last_new_ip = td.new_code + new_in_start_offset;
2876                 else if (td.is_bb_start [td.in_start - td.il_code])
2877                         td.is_bb_start [td.ip - td.il_code] = 1;
2878
2879                 td.last_ip = td.in_start;
2880         }
2881
2882         if (mono_interp_traceopt) {
2883                 const guint16 *p = td.new_code;
2884                 printf("Runtime method: %p, VT stack size: %d\n", rtm, td.max_vt_sp);
2885                 printf("Calculated stack size: %d, stated size: %d\n", td.max_stack_height, header->max_stack);
2886                 while (p < td.new_ip) {
2887                         p = mono_interp_dis_mintop(td.new_code, p);
2888                         printf("\n");
2889                 }
2890         }
2891
2892         rtm->clauses = mono_mempool_alloc (domain->mp, header->num_clauses * sizeof(MonoExceptionClause));
2893         memcpy (rtm->clauses, header->clauses, header->num_clauses * sizeof(MonoExceptionClause));
2894         rtm->code = mono_mempool_alloc (domain->mp, (td.new_ip - td.new_code) * sizeof(gushort));
2895         memcpy (rtm->code, td.new_code, (td.new_ip - td.new_code) * sizeof(gushort));
2896         g_free (td.new_code);
2897         rtm->new_body_start = rtm->code + body_start_offset;
2898         rtm->num_clauses = header->num_clauses;
2899         for (i = 0; i < header->num_clauses; i++) {
2900                 MonoExceptionClause *c = rtm->clauses + i;
2901                 int end_off = c->try_offset + c->try_len;
2902                 c->try_offset = td.in_offsets [c->try_offset];
2903                 c->try_len = td.in_offsets [end_off] - c->try_offset;
2904                 end_off = c->handler_offset + c->handler_len;
2905                 c->handler_offset = td.in_offsets [c->handler_offset];
2906                 c->handler_len = td.in_offsets [end_off] - c->handler_offset;
2907         }
2908         rtm->vt_stack_size = td.max_vt_sp;
2909         rtm->alloca_size = rtm->locals_size + rtm->args_size + rtm->vt_stack_size + rtm->stack_size;
2910         rtm->data_items = mono_mempool_alloc (domain->mp, td.n_data_items * sizeof (td.data_items [0]));
2911         memcpy (rtm->data_items, td.data_items, td.n_data_items * sizeof (td.data_items [0]));
2912         g_free (td.in_offsets);
2913         g_free (td.forward_refs);
2914         for (i = 0; i < header->code_size; ++i)
2915                 g_free (td.stack_state [i]);
2916         g_free (td.stack_state);
2917         g_free (td.stack_height);
2918         g_free (td.vt_stack_size);
2919         g_free (td.data_items);
2920         g_hash_table_destroy (td.data_hash);
2921 }
2922
2923 static mono_mutex_t calc_section;
2924
2925 void
2926 mono_interp_transform_init (void)
2927 {
2928         mono_os_mutex_init_recursive(&calc_section);
2929 }
2930
2931 MonoException *
2932 mono_interp_transform_method (RuntimeMethod *runtime_method, ThreadContext *context)
2933 {
2934         int i, align, size, offset;
2935         MonoMethod *method = runtime_method->method;
2936         MonoImage *image = method->klass->image;
2937         MonoMethodHeader *header = mono_method_get_header (method);
2938         MonoMethodSignature *signature = mono_method_signature (method);
2939         register const unsigned char *ip, *end;
2940         const MonoOpcode *opcode;
2941         MonoMethod *m;
2942         MonoClass *class;
2943         MonoDomain *domain = mono_domain_get ();
2944         unsigned char *is_bb_start;
2945         int in;
2946         MonoVTable *method_class_vt;
2947         int backwards;
2948         MonoGenericContext *generic_context = NULL;
2949
2950         // g_printerr ("TRANSFORM(0x%016lx): begin %s::%s\n", mono_thread_current (), method->klass->name, method->name);
2951         method_class_vt = mono_class_vtable (domain, runtime_method->method->klass);
2952         if (!method_class_vt->initialized) {
2953                 jmp_buf env;
2954                 MonoInvocation *last_env_frame = context->env_frame;
2955                 jmp_buf *old_env = context->current_env;
2956
2957                 if (setjmp(env)) {
2958                         MonoException *failed = context->env_frame->ex;
2959                         context->env_frame->ex = NULL;
2960                         context->env_frame = last_env_frame;
2961                         context->current_env = old_env;
2962                         return failed;
2963                 }
2964                 context->env_frame = context->current_frame;
2965                 context->current_env = &env;
2966                 mono_runtime_class_init (method_class_vt);
2967                 context->env_frame = last_env_frame;
2968                 context->current_env = old_env;
2969         }
2970
2971         mono_profiler_method_jit (method); /* sort of... */
2972
2973         if (mono_method_signature (method)->is_inflated)
2974                 generic_context = &((MonoMethodInflated *) method)->context;
2975
2976         if (method->iflags & (METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL | METHOD_IMPL_ATTRIBUTE_RUNTIME)) {
2977                 MonoMethod *nm = NULL;
2978                 mono_os_mutex_lock(&calc_section);
2979                 if (runtime_method->transformed) {
2980                         mono_os_mutex_unlock(&calc_section);
2981                         g_error ("FIXME: no jit info?");
2982                         mono_profiler_method_end_jit (method, NULL, MONO_PROFILE_OK);
2983                         return NULL;
2984                 }
2985
2986                 /* assumes all internal calls with an array this are built in... */
2987                 if (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL && (! mono_method_signature (method)->hasthis || method->klass->rank == 0)) {
2988                         nm = mono_marshal_get_native_wrapper (method, TRUE, FALSE);
2989                 } else {
2990                         const char *name = method->name;
2991                         if (method->klass->parent == mono_defaults.multicastdelegate_class) {
2992                                 if (*name == 'I' && (strcmp (name, "Invoke") == 0)) {
2993                                         nm = mono_marshal_get_delegate_invoke (method, NULL);
2994                                 } else if (*name == 'B' && (strcmp (name, "BeginInvoke") == 0)) {
2995                                         nm = mono_marshal_get_delegate_begin_invoke (method);
2996                                 } else if (*name == 'E' && (strcmp (name, "EndInvoke") == 0)) {
2997                                         nm = mono_marshal_get_delegate_end_invoke (method);
2998                                 }
2999                         }
3000                         if (nm == NULL) {
3001                                 runtime_method->code = g_malloc(sizeof(short));
3002                                 runtime_method->code[0] = MINT_CALLRUN;
3003                         }
3004                 }
3005                 if (nm == NULL) {
3006                         runtime_method->stack_size = sizeof (stackval); /* for tracing */
3007                         runtime_method->alloca_size = runtime_method->stack_size;
3008                         runtime_method->transformed = TRUE;
3009                         mono_os_mutex_unlock(&calc_section);
3010                         mono_profiler_method_end_jit (method, NULL, MONO_PROFILE_OK);
3011                         return NULL;
3012                 }
3013                 method = nm;
3014                 header = mono_method_get_header (nm);
3015                 mono_os_mutex_unlock(&calc_section);
3016         }
3017         g_assert ((signature->param_count + signature->hasthis) < 1000);
3018         g_assert (header->max_stack < 10000);
3019         /* intern the strings in the method. */
3020         ip = header->code;
3021         end = ip + header->code_size;
3022
3023         is_bb_start = g_malloc0(header->code_size);
3024         is_bb_start [0] = 1;
3025         while (ip < end) {
3026                 in = *ip;
3027                 if (in == 0xfe) {
3028                         ip++;
3029                         in = *ip + 256;
3030                 }
3031                 else if (in == 0xf0) {
3032                         ip++;
3033                         in = *ip + MONO_CEE_MONO_ICALL;
3034                 }
3035                 opcode = &mono_opcodes [in];
3036                 switch (opcode->argument) {
3037                 case MonoInlineNone:
3038                         ++ip;
3039                         break;
3040                 case MonoInlineString:
3041                         if (method->wrapper_type == MONO_WRAPPER_NONE)
3042                                 mono_ldstr (domain, image, mono_metadata_token_index (read32 (ip + 1)));
3043                         ip += 5;
3044                         break;
3045                 case MonoInlineType:
3046                         if (method->wrapper_type == MONO_WRAPPER_NONE) {
3047                                 class = mono_class_get_full (image, read32 (ip + 1), generic_context);
3048                                 mono_class_init (class);
3049                                 /* quick fix to not do this for the fake ptr classes - probably should not be getting the vtable at all here */
3050 #if 0
3051                                 g_error ("FIXME: interface method lookup: %s (in method %s)", class->name, method->name);
3052                                 if (!(class->flags & TYPE_ATTRIBUTE_INTERFACE) && class->interface_offsets != NULL)
3053                                         mono_class_vtable (domain, class);
3054 #endif
3055                         }
3056                         ip += 5;
3057                         break;
3058                 case MonoInlineMethod:
3059                         if (method->wrapper_type == MONO_WRAPPER_NONE && *ip != CEE_CALLI) {
3060                                 m = mono_get_method_full (image, read32 (ip + 1), NULL, generic_context);
3061                                 if (m == NULL) {
3062                                         g_free (is_bb_start);
3063                                         g_error ("FIXME: where to get method and class string?");
3064                                         return NULL;
3065                                         // return mono_get_exception_missing_method ();
3066                                 }
3067                                 mono_class_init (m->klass);
3068                                 if (!mono_class_is_interface (m->klass))
3069                                         mono_class_vtable (domain, m->klass);
3070                         }
3071                         ip += 5;
3072                         break;
3073                 case MonoInlineField:
3074                 case MonoInlineSig:
3075                 case MonoInlineI:
3076                 case MonoInlineTok:
3077                 case MonoShortInlineR:
3078                         ip += 5;
3079                         break;
3080                 case MonoInlineBrTarget:
3081                         offset = read32 (ip + 1);
3082                         ip += 5;
3083                         backwards = offset < 0;
3084                         offset += ip - header->code;
3085                         g_assert (offset >= 0 && offset < header->code_size);
3086                         is_bb_start [offset] |= backwards ? 2 : 1;
3087                         break;
3088                 case MonoShortInlineBrTarget:
3089                         offset = ((gint8 *)ip) [1];
3090                         ip += 2;
3091                         backwards = offset < 0;
3092                         offset += ip - header->code;
3093                         g_assert (offset >= 0 && offset < header->code_size);
3094                         is_bb_start [offset] |= backwards ? 2 : 1;
3095                         break;
3096                 case MonoInlineVar:
3097                         ip += 3;
3098                         break;
3099                 case MonoShortInlineVar:
3100                 case MonoShortInlineI:
3101                         ip += 2;
3102                         break;
3103                 case MonoInlineSwitch: {
3104                         guint32 n;
3105                         const unsigned char *next_ip;
3106                         ++ip;
3107                         n = read32 (ip);
3108                         ip += 4;
3109                         next_ip = ip + 4 * n;
3110                         for (i = 0; i < n; i++) {
3111                                 offset = read32 (ip);
3112                                 backwards = offset < 0;
3113                                 offset += next_ip - header->code;
3114                                 g_assert (offset >= 0 && offset < header->code_size);
3115                                 is_bb_start [offset] |= backwards ? 2 : 1;
3116                                 ip += 4;
3117                         }
3118                         break;
3119                 }
3120                 case MonoInlineR:
3121                 case MonoInlineI8:
3122                         ip += 9;
3123                         break;
3124                 default:
3125                         g_assert_not_reached ();
3126                 }
3127         }
3128         // g_printerr ("TRANSFORM(0x%016lx): end %s::%s\n", mono_thread_current (), method->klass->name, method->name);
3129
3130         /* the rest needs to be locked so it is only done once */
3131         mono_os_mutex_lock(&calc_section);
3132         if (runtime_method->transformed) {
3133                 mono_os_mutex_unlock(&calc_section);
3134                 g_free (is_bb_start);
3135                 mono_profiler_method_end_jit (method, NULL, MONO_PROFILE_OK);
3136                 return NULL;
3137         }
3138
3139         runtime_method->local_offsets = g_malloc (header->num_locals * sizeof(guint32));
3140         runtime_method->stack_size = (sizeof (stackval) + 2) * header->max_stack; /* + 1 for returns of called functions  + 1 for 0-ing in trace*/
3141         runtime_method->stack_size = (runtime_method->stack_size + 7) & ~7;
3142         offset = 0;
3143         for (i = 0; i < header->num_locals; ++i) {
3144                 size = mono_type_size (header->locals [i], &align);
3145                 offset += align - 1;
3146                 offset &= ~(align - 1);
3147                 runtime_method->local_offsets [i] = offset;
3148                 offset += size;
3149         }
3150         offset = (offset + 7) & ~7;
3151         runtime_method->locals_size = offset;
3152         g_assert (runtime_method->locals_size < 65536);
3153         offset = 0;
3154         runtime_method->arg_offsets = g_malloc(signature->param_count * sizeof(guint32));
3155         for (i = 0; i < signature->param_count; ++i) {
3156                 if (signature->pinvoke) {
3157                         guint32 dummy;
3158                         size = mono_type_native_stack_size (signature->params [i], &dummy);
3159                         align = 8;
3160                 }
3161                 else
3162                         size = mono_type_stack_size (signature->params [i], &align);
3163                 offset += align - 1;
3164                 offset &= ~(align - 1);
3165                 runtime_method->arg_offsets [i] = offset;
3166                 offset += size;
3167         }
3168         offset = (offset + 7) & ~7;
3169         runtime_method->args_size = offset;
3170         g_assert (runtime_method->args_size < 10000);
3171
3172         generate(method, runtime_method, is_bb_start);
3173
3174         g_free (is_bb_start);
3175
3176         mono_profiler_method_end_jit (method, NULL, MONO_PROFILE_OK);
3177         runtime_method->transformed = TRUE;
3178         mono_os_mutex_unlock(&calc_section);
3179
3180         return NULL;
3181 }
3182