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