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                                 ADD_CODE (&td, MINT_VTRESULT);
1967                                 ADD_CODE (&td, 0);
1968                                 WRITE32 (&td, &size);
1969                         }
1970                         td.ip += 5;
1971                         SET_TYPE(td.sp - 1, stack_type [mt], field_klass);
1972                         break;
1973                 }
1974                 case CEE_STFLD:
1975                         CHECK_STACK (&td, 2);
1976                         token = read32 (td.ip + 1);
1977                         field = mono_field_from_token (image, token, &klass, generic_context);
1978                         mono_class_init (klass);
1979                         mt = mint_type(field->type);
1980                         if (klass->marshalbyref) {
1981                                 ADD_CODE(&td, mt == MINT_TYPE_VT ? MINT_STRMFLD_VT : MINT_STRMFLD);
1982                                 ADD_CODE(&td, get_data_item_index (&td, field));
1983                         } else  {
1984                                 ADD_CODE(&td, MINT_STFLD_I1 + mt - MINT_TYPE_I1);
1985                                 ADD_CODE(&td, klass->valuetype ? field->offset - sizeof(MonoObject) : field->offset);
1986                         }
1987                         if (mt == MINT_TYPE_VT) {
1988                                 MonoClass *klass = mono_class_from_mono_type (field->type);
1989                                 int size = mono_class_value_size (klass, NULL);
1990                                 POP_VT(&td, size);
1991                                 WRITE32(&td, &size);
1992                         }
1993                         td.ip += 5;
1994                         td.sp -= 2;
1995                         break;
1996                 case CEE_LDSFLDA:
1997                         token = read32 (td.ip + 1);
1998                         field = mono_field_from_token (image, token, &klass, generic_context);
1999                         ADD_CODE(&td, MINT_LDSFLDA);
2000                         ADD_CODE(&td, get_data_item_index (&td, field));
2001                         td.ip += 5;
2002                         PUSH_SIMPLE_TYPE(&td, STACK_TYPE_MP);
2003                         break;
2004                 case CEE_LDSFLD:
2005                         token = read32 (td.ip + 1);
2006                         field = mono_field_from_token (image, token, &klass, generic_context);
2007                         mt = mint_type(field->type);
2008                         ADD_CODE(&td, mt == MINT_TYPE_VT ? MINT_LDSFLD_VT : MINT_LDSFLD);
2009                         ADD_CODE(&td, get_data_item_index (&td, field));
2010                         klass = NULL;
2011                         if (mt == MINT_TYPE_VT) {
2012                                 MonoClass *klass = mono_class_from_mono_type (field->type);
2013                                 int size = mono_class_value_size (klass, NULL);
2014                                 PUSH_VT(&td, size);
2015                                 WRITE32(&td, &size);
2016                                 klass = field->type->data.klass;
2017                         } else {
2018                                 if (mt == MINT_TYPE_O)
2019                                         klass = mono_class_from_mono_type (field->type);
2020                         }
2021                         td.ip += 5;
2022                         PUSH_TYPE(&td, stack_type [mt], klass);
2023                         break;
2024                 case CEE_STSFLD:
2025                         CHECK_STACK (&td, 1);
2026                         token = read32 (td.ip + 1);
2027                         field = mono_field_from_token (image, token, &klass, generic_context);
2028                         mt = mint_type(field->type);
2029                         ADD_CODE(&td, mt == MINT_TYPE_VT ? MINT_STSFLD_VT : MINT_STSFLD);
2030                         ADD_CODE(&td, get_data_item_index (&td, field));
2031                         if (mt == MINT_TYPE_VT) {
2032                                 MonoClass *klass = mono_class_from_mono_type (field->type);
2033                                 int size = mono_class_value_size (klass, NULL);
2034                                 POP_VT (&td, size);
2035                                 WRITE32 (&td, &size);
2036                         }
2037                         td.ip += 5;
2038                         --td.sp;
2039                         break;
2040                 case CEE_STOBJ: {
2041                         int size;
2042                         token = read32 (td.ip + 1);
2043
2044                         if (method->wrapper_type != MONO_WRAPPER_NONE)
2045                                 klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
2046                         else
2047                                 klass = mono_class_get_full (image, token, generic_context);
2048
2049                         ADD_CODE(&td, td.sp [-1].type == STACK_TYPE_VT ? MINT_STOBJ_VT : MINT_STOBJ);
2050                         ADD_CODE(&td, get_data_item_index (&td, klass));
2051                         if (td.sp [-1].type == STACK_TYPE_VT) {
2052                                 size = mono_class_value_size (klass, NULL);
2053                                 size = (size + 7) & ~7;
2054                                 td.vt_sp -= size;
2055                         }
2056                         td.ip += 5;
2057                         td.sp -= 2;
2058                         break;
2059                 }
2060                 case CEE_CONV_OVF_I_UN:
2061                         CHECK_STACK (&td, 1);
2062                         switch (td.sp [-1].type) {
2063                         case STACK_TYPE_R8:
2064 #if SIZEOF_VOID_P == 8
2065                                 ADD_CODE(&td, MINT_CONV_OVF_I8_UN_R8);
2066 #else
2067                                 ADD_CODE(&td, MINT_CONV_OVF_I4_UN_R8);
2068 #endif
2069                                 break;
2070                         case STACK_TYPE_I8:
2071                                 /*FIX*/
2072                                 break;
2073                         case STACK_TYPE_I4:
2074 #if SIZEOF_VOID_P == 8
2075                                 ADD_CODE(&td, MINT_CONV_I8_U4);
2076 #endif
2077                                 break;
2078                         default:
2079                                 g_assert_not_reached ();
2080                                 break;
2081                         }
2082                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I8);
2083                         ++td.ip;
2084                         break;
2085                 case CEE_CONV_OVF_I8_UN:
2086                         CHECK_STACK (&td, 1);
2087                         switch (td.sp [-1].type) {
2088                         case STACK_TYPE_R8:
2089                                 ADD_CODE(&td, MINT_CONV_OVF_I8_UN_R8);
2090                                 break;
2091                         case STACK_TYPE_I8:
2092                                 break;
2093                         case STACK_TYPE_I4:
2094                                 ADD_CODE(&td, MINT_CONV_I8_U4);
2095                                 break;
2096                         default:
2097                                 g_assert_not_reached ();
2098                                 break;
2099                         }
2100                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I8);
2101                         ++td.ip;
2102                         break;
2103                 case CEE_BOX: {
2104                         int size;
2105                         CHECK_STACK (&td, 1);
2106                         token = read32 (td.ip + 1);
2107                         if (method->wrapper_type != MONO_WRAPPER_NONE)
2108                                 klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
2109                         else
2110                                 klass = mono_class_get_full (image, token, generic_context);
2111
2112                         if (mono_class_is_nullable (klass)) {
2113                                 MonoMethod *target_method = mono_class_get_method_from_name (klass, "Box", 1);
2114                                 /* td.ip is incremented by interp_transform_call */
2115                                 interp_transform_call (&td, method, target_method, domain, generic_context, is_bb_start, body_start_offset, NULL);
2116                         } else if (!klass->valuetype) {
2117                                 /* already boxed, do nothing. */
2118                                 td.ip += 5;
2119                         } else {
2120                                 if (mint_type (&klass->byval_arg) == MINT_TYPE_VT && !klass->enumtype) {
2121                                         size = mono_class_value_size (klass, NULL);
2122                                         size = (size + 7) & ~7;
2123                                         td.vt_sp -= size;
2124                                 }
2125                                 ADD_CODE(&td, MINT_BOX);
2126                                 ADD_CODE(&td, get_data_item_index (&td, klass));
2127                                 ADD_CODE (&td, 0);
2128                                 SET_TYPE(td.sp - 1, STACK_TYPE_O, klass);
2129                                 td.ip += 5;
2130                         }
2131
2132                         break;
2133                 }
2134                 case CEE_NEWARR:
2135                         CHECK_STACK (&td, 1);
2136                         token = read32 (td.ip + 1);
2137
2138                         if (method->wrapper_type != MONO_WRAPPER_NONE)
2139                                 klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
2140                         else
2141                                 klass = mono_class_get_full (image, token, generic_context);
2142
2143                         ADD_CODE(&td, MINT_NEWARR);
2144                         ADD_CODE(&td, get_data_item_index (&td, klass));
2145                         SET_TYPE(td.sp - 1, STACK_TYPE_O, klass);
2146                         td.ip += 5;
2147                         break;
2148                 case CEE_LDLEN:
2149                         CHECK_STACK (&td, 1);
2150                         SIMPLE_OP (td, MINT_LDLEN);
2151                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I);
2152                         break;
2153                 case CEE_LDELEMA:
2154                         CHECK_STACK (&td, 2);
2155                         ENSURE_I4 (&td, 1);
2156                         token = read32 (td.ip + 1);
2157
2158                         if (method->wrapper_type != MONO_WRAPPER_NONE)
2159                                 klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
2160                         else
2161                                 klass = mono_class_get_full (image, token, generic_context);
2162
2163                         ADD_CODE(&td, MINT_LDELEMA);
2164                         ADD_CODE(&td, get_data_item_index (&td, klass));
2165                         td.ip += 5;
2166                         --td.sp;
2167                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_MP);
2168                         break;
2169                 case CEE_LDELEM_I1:
2170                         CHECK_STACK (&td, 2);
2171                         ENSURE_I4 (&td, 1);
2172                         SIMPLE_OP (td, MINT_LDELEM_I1);
2173                         --td.sp;
2174                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2175                         break;
2176                 case CEE_LDELEM_U1:
2177                         CHECK_STACK (&td, 2);
2178                         ENSURE_I4 (&td, 1);
2179                         SIMPLE_OP (td, MINT_LDELEM_U1);
2180                         --td.sp;
2181                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2182                         break;
2183                 case CEE_LDELEM_I2:
2184                         CHECK_STACK (&td, 2);
2185                         ENSURE_I4 (&td, 1);
2186                         SIMPLE_OP (td, MINT_LDELEM_I2);
2187                         --td.sp;
2188                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2189                         break;
2190                 case CEE_LDELEM_U2:
2191                         CHECK_STACK (&td, 2);
2192                         ENSURE_I4 (&td, 1);
2193                         SIMPLE_OP (td, MINT_LDELEM_U2);
2194                         --td.sp;
2195                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2196                         break;
2197                 case CEE_LDELEM_I4:
2198                         CHECK_STACK (&td, 2);
2199                         ENSURE_I4 (&td, 1);
2200                         SIMPLE_OP (td, MINT_LDELEM_I4);
2201                         --td.sp;
2202                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2203                         break;
2204                 case CEE_LDELEM_U4:
2205                         CHECK_STACK (&td, 2);
2206                         ENSURE_I4 (&td, 1);
2207                         SIMPLE_OP (td, MINT_LDELEM_U4);
2208                         --td.sp;
2209                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2210                         break;
2211                 case CEE_LDELEM_I8:
2212                         CHECK_STACK (&td, 2);
2213                         ENSURE_I4 (&td, 1);
2214                         SIMPLE_OP (td, MINT_LDELEM_I8);
2215                         --td.sp;
2216                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I8);
2217                         break;
2218                 case CEE_LDELEM_I:
2219                         CHECK_STACK (&td, 2);
2220                         ENSURE_I4 (&td, 1);
2221                         SIMPLE_OP (td, MINT_LDELEM_I);
2222                         --td.sp;
2223                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I);
2224                         break;
2225                 case CEE_LDELEM_R4:
2226                         CHECK_STACK (&td, 2);
2227                         ENSURE_I4 (&td, 1);
2228                         SIMPLE_OP (td, MINT_LDELEM_R4);
2229                         --td.sp;
2230                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_R8);
2231                         break;
2232                 case CEE_LDELEM_R8:
2233                         CHECK_STACK (&td, 2);
2234                         ENSURE_I4 (&td, 1);
2235                         SIMPLE_OP (td, MINT_LDELEM_R8);
2236                         --td.sp;
2237                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_R8);
2238                         break;
2239                 case CEE_LDELEM_REF:
2240                         CHECK_STACK (&td, 2);
2241                         ENSURE_I4 (&td, 1);
2242                         SIMPLE_OP (td, MINT_LDELEM_REF);
2243                         --td.sp;
2244                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_O);
2245                         break;
2246                 case CEE_LDELEM:
2247                         CHECK_STACK (&td, 2);
2248                         token = read32 (td.ip + 1);
2249                         klass = mono_class_get_full (image, token, generic_context);
2250                         switch (mint_type (&klass->byval_arg)) {
2251                                 case MINT_TYPE_I4:
2252                                         ENSURE_I4 (&td, 1);
2253                                         SIMPLE_OP (td, MINT_LDELEM_I4);
2254                                         --td.sp;
2255                                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2256                                         break;
2257                                 case MINT_TYPE_VT: {
2258                                         int size = mono_class_value_size (klass, NULL);
2259                                         ENSURE_I4 (&td, 1);
2260                                         SIMPLE_OP (td, MINT_LDELEM_VT);
2261                                         ADD_CODE (&td, get_data_item_index (&td, klass));
2262                                         WRITE32 (&td, &size);
2263                                         --td.sp;
2264                                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_VT);
2265                                         PUSH_VT (&td, size);
2266                                         break;
2267                                 }
2268                                 default: {
2269                                         GString *res = g_string_new ("");
2270                                         mono_type_get_desc (res, &klass->byval_arg, TRUE);
2271                                         g_print ("LDELEM: %s -> %d (%s)\n", klass->name, mint_type (&klass->byval_arg), res->str);
2272                                         g_string_free (res, TRUE);
2273                                         g_assert (0);
2274                                         break;
2275                                 }
2276                         }
2277                         td.ip += 4;
2278                         break;
2279                 case CEE_STELEM_I:
2280                         CHECK_STACK (&td, 3);
2281                         ENSURE_I4 (&td, 2);
2282                         SIMPLE_OP (td, MINT_STELEM_I);
2283                         td.sp -= 3;
2284                         break;
2285                 case CEE_STELEM_I1:
2286                         CHECK_STACK (&td, 3);
2287                         ENSURE_I4 (&td, 2);
2288                         SIMPLE_OP (td, MINT_STELEM_I1);
2289                         td.sp -= 3;
2290                         break;
2291                 case CEE_STELEM_I2:
2292                         CHECK_STACK (&td, 3);
2293                         ENSURE_I4 (&td, 2);
2294                         SIMPLE_OP (td, MINT_STELEM_I2);
2295                         td.sp -= 3;
2296                         break;
2297                 case CEE_STELEM_I4:
2298                         CHECK_STACK (&td, 3);
2299                         ENSURE_I4 (&td, 2);
2300                         SIMPLE_OP (td, MINT_STELEM_I4);
2301                         td.sp -= 3;
2302                         break;
2303                 case CEE_STELEM_I8:
2304                         CHECK_STACK (&td, 3);
2305                         ENSURE_I4 (&td, 2);
2306                         SIMPLE_OP (td, MINT_STELEM_I8);
2307                         td.sp -= 3;
2308                         break;
2309                 case CEE_STELEM_R4:
2310                         CHECK_STACK (&td, 3);
2311                         ENSURE_I4 (&td, 2);
2312                         SIMPLE_OP (td, MINT_STELEM_R4);
2313                         td.sp -= 3;
2314                         break;
2315                 case CEE_STELEM_R8:
2316                         CHECK_STACK (&td, 3);
2317                         ENSURE_I4 (&td, 2);
2318                         SIMPLE_OP (td, MINT_STELEM_R8);
2319                         td.sp -= 3;
2320                         break;
2321                 case CEE_STELEM_REF:
2322                         CHECK_STACK (&td, 3);
2323                         ENSURE_I4 (&td, 2);
2324                         SIMPLE_OP (td, MINT_STELEM_REF);
2325                         td.sp -= 3;
2326                         break;
2327                 case CEE_STELEM:
2328                         CHECK_STACK (&td, 3);
2329                         ENSURE_I4 (&td, 2);
2330                         token = read32 (td.ip + 1);
2331                         klass = mono_class_get_full (image, token, generic_context);
2332                         switch (mint_type (&klass->byval_arg)) {
2333                                 case MINT_TYPE_I4:
2334                                         SIMPLE_OP (td, MINT_STELEM_I4);
2335                                         break;
2336                                 case MINT_TYPE_O:
2337                                         SIMPLE_OP (td, MINT_STELEM_REF);
2338                                         break;
2339                                 case MINT_TYPE_VT: {
2340                                         int size = mono_class_value_size (klass, NULL);
2341                                         SIMPLE_OP (td, MINT_STELEM_VT);
2342                                         ADD_CODE (&td, get_data_item_index (&td, klass));
2343                                         WRITE32 (&td, &size);
2344                                         POP_VT (&td, size);
2345                                         break;
2346                                 }
2347                                 default: {
2348                                         GString *res = g_string_new ("");
2349                                         mono_type_get_desc (res, &klass->byval_arg, TRUE);
2350                                         g_print ("STELEM: %s -> %d (%s)\n", klass->name, mint_type (&klass->byval_arg), res->str);
2351                                         g_string_free (res, TRUE);
2352                                         g_assert (0);
2353                                         break;
2354                                 }
2355                         }
2356                         td.ip += 4;
2357                         td.sp -= 3;
2358                         break;
2359 #if 0
2360                 case CEE_CONV_OVF_U1:
2361
2362                 case CEE_CONV_OVF_I8:
2363
2364 #if SIZEOF_VOID_P == 8
2365                 case CEE_CONV_OVF_U:
2366 #endif
2367                 case CEE_REFANYVAL: ves_abort(); break;
2368 #endif
2369                 case CEE_CKFINITE:
2370                         CHECK_STACK (&td, 1);
2371                         SIMPLE_OP (td, MINT_CKFINITE);
2372                         break;
2373                 case CEE_CONV_OVF_I1:
2374                 case CEE_CONV_OVF_I1_UN:
2375                         CHECK_STACK (&td, 1);
2376                         switch (td.sp [-1].type) {
2377                         case STACK_TYPE_R8:
2378                                 ADD_CODE(&td, MINT_CONV_OVF_I1_R8);
2379                                 break;
2380                         case STACK_TYPE_I4:
2381                                 ADD_CODE(&td, MINT_CONV_OVF_I1_I4);
2382                                 break;
2383                         case STACK_TYPE_I8:
2384                                 ADD_CODE(&td, MINT_CONV_OVF_I1_I8);
2385                                 break;
2386                         default:
2387                                 g_assert_not_reached ();
2388                         }
2389                         ++td.ip;
2390                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2391                         break;
2392                 case CEE_CONV_OVF_U1:
2393                 case CEE_CONV_OVF_U1_UN:
2394                         CHECK_STACK (&td, 1);
2395                         switch (td.sp [-1].type) {
2396                         case STACK_TYPE_R8:
2397                                 ADD_CODE(&td, MINT_CONV_OVF_U1_R8);
2398                                 break;
2399                         case STACK_TYPE_I4:
2400                                 ADD_CODE(&td, MINT_CONV_OVF_U1_I4);
2401                                 break;
2402                         case STACK_TYPE_I8:
2403                                 ADD_CODE(&td, MINT_CONV_OVF_U1_I8);
2404                                 break;
2405                         default:
2406                                 g_assert_not_reached ();
2407                         }
2408                         ++td.ip;
2409                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2410                         break;
2411                 case CEE_CONV_OVF_I2:
2412                 case CEE_CONV_OVF_I2_UN:
2413                         CHECK_STACK (&td, 1);
2414                         switch (td.sp [-1].type) {
2415                         case STACK_TYPE_R8:
2416                                 ADD_CODE(&td, MINT_CONV_OVF_I2_R8);
2417                                 break;
2418                         case STACK_TYPE_I4:
2419                                 ADD_CODE(&td, MINT_CONV_OVF_I2_I4);
2420                                 break;
2421                         case STACK_TYPE_I8:
2422                                 ADD_CODE(&td, MINT_CONV_OVF_I2_I8);
2423                                 break;
2424                         default:
2425                                 g_assert_not_reached ();
2426                         }
2427                         ++td.ip;
2428                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2429                         break;
2430                 case CEE_CONV_OVF_U2_UN:
2431                 case CEE_CONV_OVF_U2:
2432                         CHECK_STACK (&td, 1);
2433                         switch (td.sp [-1].type) {
2434                         case STACK_TYPE_R8:
2435                                 ADD_CODE(&td, MINT_CONV_OVF_U2_R8);
2436                                 break;
2437                         case STACK_TYPE_I4:
2438                                 ADD_CODE(&td, MINT_CONV_OVF_U2_I4);
2439                                 break;
2440                         case STACK_TYPE_I8:
2441                                 ADD_CODE(&td, MINT_CONV_OVF_U2_I8);
2442                                 break;
2443                         default:
2444                                 g_assert_not_reached ();
2445                         }
2446                         ++td.ip;
2447                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2448                         break;
2449 #if SIZEOF_VOID_P == 4
2450                 case CEE_CONV_OVF_I:
2451 #endif
2452                 case CEE_CONV_OVF_I4:
2453                 case CEE_CONV_OVF_I4_UN:
2454                         CHECK_STACK (&td, 1);
2455                         switch (td.sp [-1].type) {
2456                         case STACK_TYPE_R8:
2457                                 ADD_CODE(&td, MINT_CONV_OVF_I4_R8);
2458                                 break;
2459                         case STACK_TYPE_I4:
2460                                 if (*td.ip == CEE_CONV_OVF_I4_UN)
2461                                         ADD_CODE(&td, MINT_CONV_OVF_I4_U4);
2462                                 break;
2463                         case STACK_TYPE_I8:
2464                                 ADD_CODE(&td, MINT_CONV_OVF_I4_I8);
2465                                 break;
2466                         default:
2467                                 g_assert_not_reached ();
2468                         }
2469                         ++td.ip;
2470                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2471                         break;
2472 #if SIZEOF_VOID_P == 4
2473                 case CEE_CONV_OVF_U:
2474 #endif
2475                 case CEE_CONV_OVF_U4:
2476                 case CEE_CONV_OVF_U4_UN:
2477                         CHECK_STACK (&td, 1);
2478                         switch (td.sp [-1].type) {
2479                         case STACK_TYPE_R8:
2480                                 ADD_CODE(&td, MINT_CONV_OVF_U4_R8);
2481                                 break;
2482                         case STACK_TYPE_I4:
2483                                 if (*td.ip != CEE_CONV_OVF_U4_UN)
2484                                         ADD_CODE(&td, MINT_CONV_OVF_U4_I4);
2485                                 break;
2486                         case STACK_TYPE_I8:
2487                                 ADD_CODE(&td, MINT_CONV_OVF_U4_I8);
2488                                 break;
2489                         default:
2490                                 g_assert_not_reached ();
2491                         }
2492                         ++td.ip;
2493                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2494                         break;
2495 #if SIZEOF_VOID_P == 8
2496                 case CEE_CONV_OVF_I:
2497 #endif
2498                 case CEE_CONV_OVF_I8:
2499                         CHECK_STACK (&td, 1);
2500                         switch (td.sp [-1].type) {
2501                         case STACK_TYPE_R8:
2502                                 ADD_CODE(&td, MINT_CONV_OVF_I8_R8);
2503                                 break;
2504                         case STACK_TYPE_I4:
2505                                 ADD_CODE(&td, MINT_CONV_I8_I4);
2506                                 break;
2507                         case STACK_TYPE_I8:
2508                                 break;
2509                         default:
2510                                 g_assert_not_reached ();
2511                         }
2512                         ++td.ip;
2513                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I8);
2514                         break;
2515 #if SIZEOF_VOID_P == 8
2516                 case CEE_CONV_OVF_U:
2517 #endif
2518                 case CEE_CONV_OVF_U8:
2519                         CHECK_STACK (&td, 1);
2520                         switch (td.sp [-1].type) {
2521                         case STACK_TYPE_R8:
2522                                 ADD_CODE(&td, MINT_CONV_OVF_U8_R8);
2523                                 break;
2524                         case STACK_TYPE_I4:
2525                                 ADD_CODE(&td, MINT_CONV_OVF_U8_I4);
2526                                 break;
2527                         case STACK_TYPE_I8:
2528                                 break;
2529                         default:
2530                                 g_assert_not_reached ();
2531                         }
2532                         ++td.ip;
2533                         SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I8);
2534                         break;
2535                 case CEE_LDTOKEN: {
2536                         int size;
2537                         gpointer handle;
2538                         token = read32 (td.ip + 1);
2539                         handle = mono_ldtoken (image, token, &klass, generic_context);
2540                         mt = mint_type(&klass->byval_arg);
2541                         g_assert (mt == MINT_TYPE_VT);
2542                         size = mono_class_value_size (klass, NULL);
2543                         g_assert (size == sizeof(gpointer));
2544                         PUSH_VT(&td, sizeof(gpointer));
2545                         ADD_CODE(&td, MINT_LDTOKEN);
2546                         ADD_CODE(&td, get_data_item_index (&td, handle));
2547                         PUSH_SIMPLE_TYPE(&td, stack_type [mt]);
2548                         td.ip += 5;
2549                         break;
2550                 }
2551                 case CEE_ADD_OVF:
2552                         binary_arith_op(&td, MINT_ADD_OVF_I4);
2553                         ++td.ip;
2554                         break;
2555                 case CEE_ADD_OVF_UN:
2556                         binary_arith_op(&td, MINT_ADD_OVF_UN_I4);
2557                         ++td.ip;
2558                         break;
2559                 case CEE_MUL_OVF:
2560                         binary_arith_op(&td, MINT_MUL_OVF_I4);
2561                         ++td.ip;
2562                         break;
2563                 case CEE_MUL_OVF_UN:
2564                         binary_arith_op(&td, MINT_MUL_OVF_UN_I4);
2565                         ++td.ip;
2566                         break;
2567                 case CEE_SUB_OVF:
2568                         binary_arith_op(&td, MINT_SUB_OVF_I4);
2569                         ++td.ip;
2570                         break;
2571                 case CEE_SUB_OVF_UN:
2572                         binary_arith_op(&td, MINT_SUB_OVF_UN_I4);
2573                         ++td.ip;
2574                         break;
2575                 case CEE_ENDFINALLY:
2576                         SIMPLE_OP (td, MINT_ENDFINALLY);
2577                         generating_code = 0;
2578                         break;
2579                 case CEE_LEAVE:
2580                         td.sp = td.stack;
2581                         handle_branch (&td, MINT_LEAVE_S, MINT_LEAVE, 5 + read32 (td.ip + 1));
2582                         td.ip += 5;
2583                         generating_code = 0;
2584                         break;
2585                 case CEE_LEAVE_S:
2586                         td.sp = td.stack;
2587                         handle_branch (&td, MINT_LEAVE_S, MINT_LEAVE, 2 + (gint8)td.ip [1]);
2588                         td.ip += 2;
2589                         generating_code = 0;
2590                         break;
2591                 case CEE_UNUSED41:
2592                         ++td.ip;
2593                         switch (*td.ip) {
2594                                 case CEE_MONO_CALLI_EXTRA_ARG:
2595                                         /* Same as CEE_CALLI, llvm specific */
2596                                         interp_transform_call (&td, method, NULL, domain, generic_context, is_bb_start, body_start_offset, NULL);
2597                                         break;
2598                                 case CEE_MONO_ICALL: {
2599                                         guint32 token;
2600                                         gpointer func;
2601                                         MonoJitICallInfo *info;
2602
2603                                         token = read32 (td.ip + 1);
2604                                         td.ip += 5;
2605                                         func = mono_method_get_wrapper_data (method, token);
2606                                         info = mono_find_jit_icall_by_addr (func);
2607                                         g_assert (info);
2608
2609                                         CHECK_STACK (&td, info->sig->param_count);
2610                                         switch (info->sig->param_count) {
2611                                         case 0:
2612                                                 if (MONO_TYPE_IS_VOID (info->sig->ret))
2613                                                         ADD_CODE (&td,MINT_ICALL_V_V);
2614                                                 else
2615                                                         ADD_CODE (&td, MINT_ICALL_V_P);
2616                                                 break;
2617                                         case 1:
2618                                                 if (MONO_TYPE_IS_VOID (info->sig->ret))
2619                                                         ADD_CODE (&td,MINT_ICALL_P_V);
2620                                                 else
2621                                                         ADD_CODE (&td,MINT_ICALL_P_P);
2622                                                 break;
2623                                         case 2:
2624                                                 if (MONO_TYPE_IS_VOID (info->sig->ret)) {
2625                                                         if (info->sig->params [1]->type == MONO_TYPE_I4)
2626                                                                 ADD_CODE (&td,MINT_ICALL_PI_V);
2627                                                         else
2628                                                                 ADD_CODE (&td,MINT_ICALL_PP_V);
2629                                                 } else {
2630                                                         if (info->sig->params [1]->type == MONO_TYPE_I4)
2631                                                                 ADD_CODE (&td,MINT_ICALL_PI_P);
2632                                                         else
2633                                                                 ADD_CODE (&td,MINT_ICALL_PP_P);
2634                                                 }
2635                                                 break;
2636                                         case 3:
2637                                                 g_assert (MONO_TYPE_IS_VOID (info->sig->ret));
2638                                                 if (info->sig->params [2]->type == MONO_TYPE_I4)
2639                                                         ADD_CODE (&td,MINT_ICALL_PPI_V);
2640                                                 else
2641                                                         ADD_CODE (&td,MINT_ICALL_PPP_V);
2642                                                 break;
2643                                         default:
2644                                                 g_assert_not_reached ();
2645                                         }
2646
2647                                         if (func == mono_ftnptr_to_delegate) {
2648                                                 g_error ("TODO: ?");
2649                                                 func = mono_interp_ftnptr_to_delegate;
2650                                         }
2651                                         ADD_CODE(&td, get_data_item_index (&td, func));
2652                                         td.sp -= info->sig->param_count;
2653
2654                                         if (!MONO_TYPE_IS_VOID (info->sig->ret)) {
2655                                                 td.sp ++;
2656                                                 SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I);
2657                                         }
2658                                         break;
2659                                 }
2660                         case CEE_MONO_VTADDR: {
2661                                 int size;
2662                                 CHECK_STACK (&td, 1);
2663                                 if (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE)
2664                                         size = mono_class_native_size(td.sp [-1].klass, NULL);
2665                                 else
2666                                         size = mono_class_value_size(td.sp [-1].klass, NULL);
2667                                 size = (size + 7) & ~7;
2668                                 ADD_CODE(&td, MINT_VTRESULT);
2669                                 ADD_CODE(&td, 0);
2670                                 WRITE32(&td, &size);
2671                                 td.vt_sp -= size;
2672                                 ++td.ip;
2673                                 SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_MP);
2674                                 break;
2675                         }
2676                         case CEE_MONO_LDPTR:
2677                         case CEE_MONO_CLASSCONST:
2678                                 token = read32 (td.ip + 1);
2679                                 td.ip += 5;
2680                                 ADD_CODE(&td, MINT_MONO_LDPTR);
2681                                 ADD_CODE(&td, get_data_item_index (&td, mono_method_get_wrapper_data (method, token)));
2682                                 td.sp [0].type = STACK_TYPE_I;
2683                                 ++td.sp;
2684                                 break;
2685                         case CEE_MONO_OBJADDR:
2686                                 CHECK_STACK (&td, 1);
2687                                 ++td.ip;
2688                                 td.sp[-1].type = STACK_TYPE_MP;
2689                                 /* do nothing? */
2690                                 break;
2691                         case CEE_MONO_NEWOBJ:
2692                                 token = read32 (td.ip + 1);
2693                                 td.ip += 5;
2694                                 ADD_CODE(&td, MINT_MONO_NEWOBJ);
2695                                 ADD_CODE(&td, get_data_item_index (&td, mono_method_get_wrapper_data (method, token)));
2696                                 td.sp [0].type = STACK_TYPE_O;
2697                                 ++td.sp;
2698                                 break;
2699                         case CEE_MONO_RETOBJ:
2700                                 CHECK_STACK (&td, 1);
2701                                 token = read32 (td.ip + 1);
2702                                 td.ip += 5;
2703                                 ADD_CODE(&td, MINT_MONO_RETOBJ);
2704                                 td.sp--;
2705
2706                                 klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
2707
2708                                 /*stackval_from_data (signature->ret, frame->retval, sp->data.vt, signature->pinvoke);*/
2709
2710                                 if (td.sp > td.stack)
2711                                         g_warning ("CEE_MONO_RETOBJ: more values on stack: %d", td.sp-td.stack);
2712                                 break;
2713                         case CEE_MONO_LDNATIVEOBJ:
2714                                 token = read32 (td.ip + 1);
2715                                 td.ip += 5;
2716                                 klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
2717                                 g_assert(klass->valuetype);
2718                                 SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_MP);
2719                                 break;
2720                         case CEE_MONO_SAVE_LMF:
2721                         case CEE_MONO_RESTORE_LMF:
2722                         case CEE_MONO_NOT_TAKEN:
2723                                 ++td.ip;
2724                                 break;
2725                         case CEE_MONO_LDPTR_INT_REQ_FLAG:
2726                                 ADD_CODE (&td, MINT_MONO_LDPTR);
2727                                 ADD_CODE (&td, get_data_item_index (&td, mono_thread_interruption_request_flag ()));
2728                                 PUSH_TYPE (&td, STACK_TYPE_MP, NULL);
2729                                 ++td.ip;
2730                                 break;
2731                         default:
2732                                 g_error ("transform.c: Unimplemented opcode: 0xF0 %02x at 0x%x\n", *td.ip, td.ip-header->code);
2733                         }
2734                         break;
2735 #if 0
2736                 case CEE_PREFIX7:
2737                 case CEE_PREFIX6:
2738                 case CEE_PREFIX5:
2739                 case CEE_PREFIX4:
2740                 case CEE_PREFIX3:
2741                 case CEE_PREFIX2:
2742                 case CEE_PREFIXREF: ves_abort(); break;
2743 #endif
2744                 /*
2745                  * Note: Exceptions thrown when executing a prefixed opcode need
2746                  * to take into account the number of prefix bytes (usually the
2747                  * throw point is just (ip - n_prefix_bytes).
2748                  */
2749                 case CEE_PREFIX1:
2750                         ++td.ip;
2751                         switch (*td.ip) {
2752 #if 0
2753                         case CEE_ARGLIST: ves_abort(); break;
2754 #endif
2755                         case CEE_CEQ:
2756                                 CHECK_STACK(&td, 2);
2757                                 if (td.sp [-1].type == STACK_TYPE_O || td.sp [-1].type == STACK_TYPE_MP)
2758                                         ADD_CODE(&td, MINT_CEQ_I4 + STACK_TYPE_I - STACK_TYPE_I4);
2759                                 else
2760                                         ADD_CODE(&td, MINT_CEQ_I4 + td.sp [-1].type - STACK_TYPE_I4);
2761                                 --td.sp;
2762                                 SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2763                                 ++td.ip;
2764                                 break;
2765                         case CEE_CGT:
2766                                 CHECK_STACK(&td, 2);
2767                                 if (td.sp [-1].type == STACK_TYPE_O || td.sp [-1].type == STACK_TYPE_MP)
2768                                         ADD_CODE(&td, MINT_CGT_I4 + STACK_TYPE_I - STACK_TYPE_I4);
2769                                 else
2770                                         ADD_CODE(&td, MINT_CGT_I4 + td.sp [-1].type - STACK_TYPE_I4);
2771                                 --td.sp;
2772                                 SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2773                                 ++td.ip;
2774                                 break;
2775                         case CEE_CGT_UN:
2776                                 CHECK_STACK(&td, 2);
2777                                 if (td.sp [-1].type == STACK_TYPE_O || td.sp [-1].type == STACK_TYPE_MP)
2778                                         ADD_CODE(&td, MINT_CGT_UN_I4 + STACK_TYPE_I - STACK_TYPE_I4);
2779                                 else
2780                                         ADD_CODE(&td, MINT_CGT_UN_I4 + td.sp [-1].type - STACK_TYPE_I4);
2781                                 --td.sp;
2782                                 SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2783                                 ++td.ip;
2784                                 break;
2785                         case CEE_CLT:
2786                                 CHECK_STACK(&td, 2);
2787                                 if (td.sp [-1].type == STACK_TYPE_O || td.sp [-1].type == STACK_TYPE_MP)
2788                                         ADD_CODE(&td, MINT_CLT_I4 + STACK_TYPE_I - STACK_TYPE_I4);
2789                                 else
2790                                         ADD_CODE(&td, MINT_CLT_I4 + td.sp [-1].type - STACK_TYPE_I4);
2791                                 --td.sp;
2792                                 SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2793                                 ++td.ip;
2794                                 break;
2795                         case CEE_CLT_UN:
2796                                 CHECK_STACK(&td, 2);
2797                                 if (td.sp [-1].type == STACK_TYPE_O || td.sp [-1].type == STACK_TYPE_MP)
2798                                         ADD_CODE(&td, MINT_CLT_UN_I4 + STACK_TYPE_I - STACK_TYPE_I4);
2799                                 else
2800                                         ADD_CODE(&td, MINT_CLT_UN_I4 + td.sp [-1].type - STACK_TYPE_I4);
2801                                 --td.sp;
2802                                 SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_I4);
2803                                 ++td.ip;
2804                                 break;
2805                         case CEE_LDVIRTFTN: /* fallthrough */
2806                         case CEE_LDFTN: {
2807                                 MonoMethod *m;
2808                                 if (*td.ip == CEE_LDVIRTFTN) {
2809                                         CHECK_STACK (&td, 1);
2810                                         --td.sp;
2811                                 }
2812                                 token = read32 (td.ip + 1);
2813                                 if (method->wrapper_type != MONO_WRAPPER_NONE)
2814                                         m = (MonoMethod *)mono_method_get_wrapper_data (method, token);
2815                                 else
2816                                         m = mono_get_method_full (image, token, NULL, generic_context);
2817
2818                                 if (method->wrapper_type == MONO_WRAPPER_NONE && m->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED)
2819                                         m = mono_marshal_get_synchronized_wrapper (m);
2820
2821                                 ADD_CODE(&td, *td.ip == CEE_LDFTN ? MINT_LDFTN : MINT_LDVIRTFTN);
2822                                 ADD_CODE(&td, get_data_item_index (&td, mono_interp_get_runtime_method (domain, m, &error)));
2823                                 mono_error_cleanup (&error); /* FIXME: don't swallow the error */
2824                                 td.ip += 5;
2825                                 PUSH_SIMPLE_TYPE (&td, STACK_TYPE_F);
2826                                 break;
2827                         }
2828                         case CEE_LDARG:
2829                                 load_arg (&td, read16 (td.ip + 1));
2830                                 td.ip += 3;
2831                                 break;
2832                         case CEE_LDARGA: {
2833                                 int n = read16 (td.ip + 1);
2834                                 if (n == 0 && signature->hasthis) {
2835                                         g_error ("LDTHISA: NOPE");
2836                                         ADD_CODE(&td, MINT_LDTHISA);
2837                                 }
2838                                 else {
2839                                         ADD_CODE(&td, MINT_LDARGA);
2840                                         ADD_CODE(&td, td.rtm->arg_offsets [n]); /* FIX for large offsets */
2841                                 }
2842                                 PUSH_SIMPLE_TYPE(&td, STACK_TYPE_MP);
2843                                 td.ip += 3;
2844                                 break;
2845                         }
2846                         case CEE_STARG:
2847                                 store_arg (&td, read16 (td.ip + 1));
2848                                 td.ip += 3;
2849                                 break;
2850                         case CEE_LDLOC:
2851                                 load_local (&td, read16 (td.ip + 1));
2852                                 td.ip += 3;
2853                                 break;
2854                         case CEE_LDLOCA:
2855                                 ADD_CODE(&td, MINT_LDLOCA_S);
2856                                 ADD_CODE(&td, td.rtm->local_offsets [read16 (td.ip + 1)]);
2857                                 PUSH_SIMPLE_TYPE(&td, STACK_TYPE_MP);
2858                                 td.ip += 3;
2859                                 break;
2860                         case CEE_STLOC:
2861                                 store_local (&td, read16 (td.ip + 1));
2862                                 td.ip += 3;
2863                                 break;
2864                         case CEE_LOCALLOC:
2865                                 CHECK_STACK (&td, 1);
2866 #if SIZEOF_VOID_P == 8
2867                                 if (td.sp [-1].type == STACK_TYPE_I8)
2868                                         ADD_CODE(&td, MINT_CONV_I4_I8);
2869 #endif
2870                                 ADD_CODE(&td, MINT_LOCALLOC);
2871                                 if (td.sp != td.stack + 1)
2872                                         g_warning("CEE_LOCALLOC: stack not empty");
2873                                 ++td.ip;
2874                                 SET_SIMPLE_TYPE(td.sp - 1, STACK_TYPE_MP);
2875                                 break;
2876 #if 0
2877                         case CEE_UNUSED57: ves_abort(); break;
2878                         case CEE_ENDFILTER: ves_abort(); break;
2879 #endif
2880                         case CEE_UNALIGNED_:
2881                                 ++td.ip;
2882                                 /* FIX: should do something? */;
2883                                 break;
2884                         case CEE_VOLATILE_:
2885                                 ++td.ip;
2886                                 /* FIX: should do something? */;
2887                                 break;
2888                         case CEE_TAIL_:
2889                                 ++td.ip;
2890                                 /* FIX: should do something? */;
2891                                 break;
2892                         case CEE_INITOBJ:
2893                                 CHECK_STACK(&td, 1);
2894                                 token = read32 (td.ip + 1);
2895                                 klass = mono_class_get_full (image, token, generic_context);
2896                                 ADD_CODE(&td, MINT_INITOBJ);
2897                                 i32 = mono_class_value_size (klass, NULL);
2898                                 WRITE32(&td, &i32);
2899                                 td.ip += 5;
2900                                 --td.sp;
2901                                 break;
2902                         case CEE_CPBLK:
2903                                 CHECK_STACK(&td, 3);
2904                                 /* FIX? convert length to I8? */
2905                                 ADD_CODE(&td, MINT_CPBLK);
2906                                 td.sp -= 3;
2907                                 ++td.ip;
2908                                 break;
2909                         case CEE_CONSTRAINED_:
2910                                 token = read32 (td.ip + 1);
2911                                 constrained_class = mono_class_get_full (image, token, generic_context);
2912                                 mono_class_init (constrained_class);
2913                                 td.ip += 5;
2914                                 break;
2915                         case CEE_INITBLK:
2916                                 CHECK_STACK(&td, 3);
2917                                 ADD_CODE(&td, MINT_INITBLK);
2918                                 td.sp -= 3;
2919                                 break;
2920 #if 0
2921                         case CEE_NO_:
2922                                 /* FIXME: implement */
2923                                 ip += 2;
2924                                 break;
2925 #endif
2926                         case CEE_RETHROW:
2927                                 SIMPLE_OP (td, MINT_RETHROW);
2928                                 generating_code = 0;
2929                                 break;
2930                         case CEE_SIZEOF: {
2931                                 gint32 size;
2932                                 token = read32 (td.ip + 1);
2933                                 td.ip += 5;
2934                                 if (mono_metadata_token_table (token) == MONO_TABLE_TYPESPEC) {
2935                                         int align;
2936                                         MonoType *type = mono_type_create_from_typespec (image, token);
2937                                         size = mono_type_size (type, &align);
2938                                 } else {
2939                                         guint32 align;
2940                                         MonoClass *szclass = mono_class_get_full (image, token, generic_context);
2941                                         mono_class_init (szclass);
2942 #if 0
2943                                         if (!szclass->valuetype)
2944                                                 THROW_EX (mono_exception_from_name (mono_defaults.corlib, "System", "InvalidProgramException"), ip - 5);
2945 #endif
2946                                         size = mono_class_value_size (szclass, &align);
2947                                 }
2948                                 ADD_CODE(&td, MINT_LDC_I4);
2949                                 WRITE32(&td, &size);
2950                                 PUSH_SIMPLE_TYPE(&td, STACK_TYPE_I4);
2951                                 break;
2952                         }
2953 #if 0
2954                         case CEE_REFANYTYPE: ves_abort(); break;
2955 #endif
2956                         default:
2957                                 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);
2958                         }
2959                         break;
2960                 default:
2961                         g_error ("transform.c: Unimplemented opcode: %02x at 0x%x\n", *td.ip, td.ip-header->code);
2962                 }
2963
2964                 if (td.new_ip - td.new_code != new_in_start_offset)
2965                         td.last_new_ip = td.new_code + new_in_start_offset;
2966                 else if (td.is_bb_start [td.in_start - td.il_code])
2967                         td.is_bb_start [td.ip - td.il_code] = 1;
2968
2969                 td.last_ip = td.in_start;
2970         }
2971
2972         if (mono_interp_traceopt) {
2973                 const guint16 *p = td.new_code;
2974                 printf("Runtime method: %p, VT stack size: %d\n", rtm, td.max_vt_sp);
2975                 printf("Calculated stack size: %d, stated size: %d\n", td.max_stack_height, header->max_stack);
2976                 while (p < td.new_ip) {
2977                         p = mono_interp_dis_mintop(td.new_code, p);
2978                         printf("\n");
2979                 }
2980         }
2981
2982         rtm->clauses = mono_mempool_alloc (domain->mp, header->num_clauses * sizeof(MonoExceptionClause));
2983         memcpy (rtm->clauses, header->clauses, header->num_clauses * sizeof(MonoExceptionClause));
2984         rtm->code = mono_mempool_alloc (domain->mp, (td.new_ip - td.new_code) * sizeof(gushort));
2985         memcpy (rtm->code, td.new_code, (td.new_ip - td.new_code) * sizeof(gushort));
2986         g_free (td.new_code);
2987         rtm->new_body_start = rtm->code + body_start_offset;
2988         rtm->num_clauses = header->num_clauses;
2989         for (i = 0; i < header->num_clauses; i++) {
2990                 MonoExceptionClause *c = rtm->clauses + i;
2991                 int end_off = c->try_offset + c->try_len;
2992                 c->try_offset = td.in_offsets [c->try_offset];
2993                 c->try_len = td.in_offsets [end_off] - c->try_offset;
2994                 end_off = c->handler_offset + c->handler_len;
2995                 c->handler_offset = td.in_offsets [c->handler_offset];
2996                 c->handler_len = td.in_offsets [end_off] - c->handler_offset;
2997         }
2998         rtm->vt_stack_size = td.max_vt_sp;
2999         rtm->alloca_size = rtm->locals_size + rtm->args_size + rtm->vt_stack_size + rtm->stack_size;
3000         rtm->data_items = mono_mempool_alloc (domain->mp, td.n_data_items * sizeof (td.data_items [0]));
3001         memcpy (rtm->data_items, td.data_items, td.n_data_items * sizeof (td.data_items [0]));
3002         g_free (td.in_offsets);
3003         g_free (td.forward_refs);
3004         for (i = 0; i < header->code_size; ++i)
3005                 g_free (td.stack_state [i]);
3006         g_free (td.stack_state);
3007         g_free (td.stack_height);
3008         g_free (td.vt_stack_size);
3009         g_free (td.data_items);
3010         g_hash_table_destroy (td.data_hash);
3011 }
3012
3013 static mono_mutex_t calc_section;
3014
3015 void
3016 mono_interp_transform_init (void)
3017 {
3018         mono_os_mutex_init_recursive(&calc_section);
3019 }
3020
3021 MonoException *
3022 mono_interp_transform_method (RuntimeMethod *runtime_method, ThreadContext *context)
3023 {
3024         int i, align, size, offset;
3025         MonoMethod *method = runtime_method->method;
3026         MonoImage *image = method->klass->image;
3027         MonoMethodHeader *header = mono_method_get_header (method);
3028         MonoMethodSignature *signature = mono_method_signature (method);
3029         register const unsigned char *ip, *end;
3030         const MonoOpcode *opcode;
3031         MonoMethod *m;
3032         MonoClass *class;
3033         MonoDomain *domain = mono_domain_get ();
3034         unsigned char *is_bb_start;
3035         int in;
3036         MonoVTable *method_class_vt;
3037         int backwards;
3038         MonoGenericContext *generic_context = NULL;
3039
3040         // g_printerr ("TRANSFORM(0x%016lx): begin %s::%s\n", mono_thread_current (), method->klass->name, method->name);
3041         method_class_vt = mono_class_vtable (domain, runtime_method->method->klass);
3042         if (!method_class_vt->initialized) {
3043                 jmp_buf env;
3044                 MonoInvocation *last_env_frame = context->env_frame;
3045                 jmp_buf *old_env = context->current_env;
3046
3047                 if (setjmp(env)) {
3048                         MonoException *failed = context->env_frame->ex;
3049                         context->env_frame->ex = NULL;
3050                         context->env_frame = last_env_frame;
3051                         context->current_env = old_env;
3052                         return failed;
3053                 }
3054                 context->env_frame = context->current_frame;
3055                 context->current_env = &env;
3056                 mono_runtime_class_init (method_class_vt);
3057                 context->env_frame = last_env_frame;
3058                 context->current_env = old_env;
3059         }
3060
3061         mono_profiler_method_jit (method); /* sort of... */
3062
3063         if (mono_method_signature (method)->is_inflated)
3064                 generic_context = &((MonoMethodInflated *) method)->context;
3065
3066         if (method->iflags & (METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL | METHOD_IMPL_ATTRIBUTE_RUNTIME)) {
3067                 MonoMethod *nm = NULL;
3068                 mono_os_mutex_lock(&calc_section);
3069                 if (runtime_method->transformed) {
3070                         mono_os_mutex_unlock(&calc_section);
3071                         g_error ("FIXME: no jit info?");
3072                         mono_profiler_method_end_jit (method, NULL, MONO_PROFILE_OK);
3073                         return NULL;
3074                 }
3075
3076                 /* assumes all internal calls with an array this are built in... */
3077                 if (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL && (! mono_method_signature (method)->hasthis || method->klass->rank == 0)) {
3078                         nm = mono_marshal_get_native_wrapper (method, TRUE, FALSE);
3079                         signature = mono_method_signature (nm);
3080                 } else {
3081                         const char *name = method->name;
3082                         if (method->klass->parent == mono_defaults.multicastdelegate_class) {
3083                                 if (*name == 'I' && (strcmp (name, "Invoke") == 0)) {
3084                                         nm = mono_marshal_get_delegate_invoke (method, NULL);
3085                                 } else if (*name == 'B' && (strcmp (name, "BeginInvoke") == 0)) {
3086                                         nm = mono_marshal_get_delegate_begin_invoke (method);
3087                                 } else if (*name == 'E' && (strcmp (name, "EndInvoke") == 0)) {
3088                                         nm = mono_marshal_get_delegate_end_invoke (method);
3089                                 }
3090                         }
3091                         if (nm == NULL) {
3092                                 runtime_method->code = g_malloc(sizeof(short));
3093                                 runtime_method->code[0] = MINT_CALLRUN;
3094                         }
3095                 }
3096                 if (nm == NULL) {
3097                         runtime_method->stack_size = sizeof (stackval); /* for tracing */
3098                         runtime_method->alloca_size = runtime_method->stack_size;
3099                         runtime_method->transformed = TRUE;
3100                         mono_os_mutex_unlock(&calc_section);
3101                         mono_profiler_method_end_jit (method, NULL, MONO_PROFILE_OK);
3102                         return NULL;
3103                 }
3104                 method = nm;
3105                 header = mono_method_get_header (nm);
3106                 mono_os_mutex_unlock(&calc_section);
3107         }
3108         g_assert ((signature->param_count + signature->hasthis) < 1000);
3109         g_assert (header->max_stack < 10000);
3110         /* intern the strings in the method. */
3111         ip = header->code;
3112         end = ip + header->code_size;
3113
3114         is_bb_start = g_malloc0(header->code_size);
3115         is_bb_start [0] = 1;
3116         while (ip < end) {
3117                 in = *ip;
3118                 if (in == 0xfe) {
3119                         ip++;
3120                         in = *ip + 256;
3121                 }
3122                 else if (in == 0xf0) {
3123                         ip++;
3124                         in = *ip + MONO_CEE_MONO_ICALL;
3125                 }
3126                 opcode = &mono_opcodes [in];
3127                 switch (opcode->argument) {
3128                 case MonoInlineNone:
3129                         ++ip;
3130                         break;
3131                 case MonoInlineString:
3132                         if (method->wrapper_type == MONO_WRAPPER_NONE)
3133                                 mono_ldstr (domain, image, mono_metadata_token_index (read32 (ip + 1)));
3134                         ip += 5;
3135                         break;
3136                 case MonoInlineType:
3137                         if (method->wrapper_type == MONO_WRAPPER_NONE) {
3138                                 class = mono_class_get_full (image, read32 (ip + 1), generic_context);
3139                                 mono_class_init (class);
3140                                 /* quick fix to not do this for the fake ptr classes - probably should not be getting the vtable at all here */
3141 #if 0
3142                                 g_error ("FIXME: interface method lookup: %s (in method %s)", class->name, method->name);
3143                                 if (!(class->flags & TYPE_ATTRIBUTE_INTERFACE) && class->interface_offsets != NULL)
3144                                         mono_class_vtable (domain, class);
3145 #endif
3146                         }
3147                         ip += 5;
3148                         break;
3149                 case MonoInlineMethod:
3150                         if (method->wrapper_type == MONO_WRAPPER_NONE && *ip != CEE_CALLI) {
3151                                 m = mono_get_method_full (image, read32 (ip + 1), NULL, generic_context);
3152                                 if (m == NULL) {
3153                                         g_free (is_bb_start);
3154                                         g_error ("FIXME: where to get method and class string?");
3155                                         return NULL;
3156                                         // return mono_get_exception_missing_method ();
3157                                 }
3158                                 mono_class_init (m->klass);
3159                                 if (!mono_class_is_interface (m->klass))
3160                                         mono_class_vtable (domain, m->klass);
3161                         }
3162                         ip += 5;
3163                         break;
3164                 case MonoInlineField:
3165                 case MonoInlineSig:
3166                 case MonoInlineI:
3167                 case MonoInlineTok:
3168                 case MonoShortInlineR:
3169                         ip += 5;
3170                         break;
3171                 case MonoInlineBrTarget:
3172                         offset = read32 (ip + 1);
3173                         ip += 5;
3174                         backwards = offset < 0;
3175                         offset += ip - header->code;
3176                         g_assert (offset >= 0 && offset < header->code_size);
3177                         is_bb_start [offset] |= backwards ? 2 : 1;
3178                         break;
3179                 case MonoShortInlineBrTarget:
3180                         offset = ((gint8 *)ip) [1];
3181                         ip += 2;
3182                         backwards = offset < 0;
3183                         offset += ip - header->code;
3184                         g_assert (offset >= 0 && offset < header->code_size);
3185                         is_bb_start [offset] |= backwards ? 2 : 1;
3186                         break;
3187                 case MonoInlineVar:
3188                         ip += 3;
3189                         break;
3190                 case MonoShortInlineVar:
3191                 case MonoShortInlineI:
3192                         ip += 2;
3193                         break;
3194                 case MonoInlineSwitch: {
3195                         guint32 n;
3196                         const unsigned char *next_ip;
3197                         ++ip;
3198                         n = read32 (ip);
3199                         ip += 4;
3200                         next_ip = ip + 4 * n;
3201                         for (i = 0; i < n; i++) {
3202                                 offset = read32 (ip);
3203                                 backwards = offset < 0;
3204                                 offset += next_ip - header->code;
3205                                 g_assert (offset >= 0 && offset < header->code_size);
3206                                 is_bb_start [offset] |= backwards ? 2 : 1;
3207                                 ip += 4;
3208                         }
3209                         break;
3210                 }
3211                 case MonoInlineR:
3212                 case MonoInlineI8:
3213                         ip += 9;
3214                         break;
3215                 default:
3216                         g_assert_not_reached ();
3217                 }
3218         }
3219         // g_printerr ("TRANSFORM(0x%016lx): end %s::%s\n", mono_thread_current (), method->klass->name, method->name);
3220
3221         /* the rest needs to be locked so it is only done once */
3222         mono_os_mutex_lock(&calc_section);
3223         if (runtime_method->transformed) {
3224                 mono_os_mutex_unlock(&calc_section);
3225                 g_free (is_bb_start);
3226                 mono_profiler_method_end_jit (method, NULL, MONO_PROFILE_OK);
3227                 return NULL;
3228         }
3229
3230         runtime_method->local_offsets = g_malloc (header->num_locals * sizeof(guint32));
3231         runtime_method->stack_size = (sizeof (stackval) + 2) * header->max_stack; /* + 1 for returns of called functions  + 1 for 0-ing in trace*/
3232         runtime_method->stack_size = (runtime_method->stack_size + 7) & ~7;
3233         offset = 0;
3234         for (i = 0; i < header->num_locals; ++i) {
3235                 size = mono_type_size (header->locals [i], &align);
3236                 offset += align - 1;
3237                 offset &= ~(align - 1);
3238                 runtime_method->local_offsets [i] = offset;
3239                 offset += size;
3240         }
3241         offset = (offset + 7) & ~7;
3242         runtime_method->locals_size = offset;
3243         g_assert (runtime_method->locals_size < 65536);
3244         offset = 0;
3245         runtime_method->arg_offsets = g_malloc ((!!signature->hasthis + signature->param_count) * sizeof(guint32));
3246
3247         if (signature->hasthis) {
3248                 g_assert (!signature->pinvoke);
3249                 size = mono_type_stack_size (&method->klass->byval_arg, &align);
3250                 offset += align - 1;
3251                 offset &= ~(align - 1);
3252                 runtime_method->arg_offsets [0] = offset;
3253                 offset += size;
3254         }
3255
3256         for (i = 0; i < signature->param_count; ++i) {
3257                 if (signature->pinvoke) {
3258                         guint32 dummy;
3259                         size = mono_type_native_stack_size (signature->params [i], &dummy);
3260                         align = 8;
3261                 }
3262                 else
3263                         size = mono_type_stack_size (signature->params [i], &align);
3264                 offset += align - 1;
3265                 offset &= ~(align - 1);
3266                 runtime_method->arg_offsets [i + !!signature->hasthis] = offset;
3267                 offset += size;
3268         }
3269         offset = (offset + 7) & ~7;
3270         runtime_method->args_size = offset;
3271         g_assert (runtime_method->args_size < 10000);
3272
3273         generate(method, runtime_method, is_bb_start);
3274
3275         g_free (is_bb_start);
3276
3277         mono_profiler_method_end_jit (method, NULL, MONO_PROFILE_OK);
3278         runtime_method->transformed = TRUE;
3279         mono_os_mutex_unlock(&calc_section);
3280
3281         return NULL;
3282 }
3283