mono/mini/mini-codegen.c

   1 /*
   2  * mini-codegen.c: Arch independent code generation functionality
   3  *
   4  * (C) 2003 Ximian, Inc.
   5  */
   6
   7 #include <string.h>
   8 #include <math.h>
   9 #ifdef HAVE_UNISTD_H
  10 #include <unistd.h>
  11 #endif
  12
  13 #include <mono/metadata/appdomain.h>
  14 #include <mono/metadata/debug-helpers.h>
  15 #include <mono/metadata/threads.h>
  16 #include <mono/metadata/profiler-private.h>
  17 #include <mono/utils/mono-math.h>
  18
  19 #include "mini.h"
  20 #include "trace.h"
  21 #include "inssel.h"
  22 #include "mini-arch.h"
  23
  24 #define DEBUG(a) MINI_DEBUG(cfg->verbose_level, 2, a;)
  25
  26 #define use_fpstack MONO_ARCH_USE_FPSTACK
  27
  28 static inline GSList*
  29 g_slist_append_mempool (MonoMemPool *mp, GSList *list, gpointer data)
  30 {
  31         GSList *new_list;
  32         GSList *last;
  33
  34         new_list = mono_mempool_alloc (mp, sizeof (GSList));
  35         new_list->data = data;
  36         new_list->next = NULL;
  37
  38         if (list) {
  39                 last = list;
  40                 while (last->next)
  41                         last = last->next;
  42                 last->next = new_list;
  43
  44                 return list;
  45         } else
  46                 return new_list;
  47 }
  48
  49 /**
  50  * Duplicated here from regalloc.c so they can be inlined
  51  * FIXME: Remove the old one after the new JIT is done
  52  */
  53
  54 static inline void
  55 mono_regstate2_reset (MonoRegState *rs) {
  56         rs->next_vreg = MONO_MAX_IREGS;
  57 }
  58
  59 static inline MonoRegState*
  60 mono_regstate2_new (void)
  61 {
  62         MonoRegState* rs = g_new0 (MonoRegState, 1);
  63
  64         mono_regstate2_reset (rs);
  65
  66         return rs;
  67 }
  68
  69 static inline void
  70 mono_regstate2_free (MonoRegState *rs) {
  71         g_free (rs->vassign);
  72         g_free (rs);
  73 }
  74
  75 static inline void
  76 mono_regstate_assign (MonoRegState *rs) {
  77         if (rs->next_vreg > rs->vassign_size) {
  78                 g_free (rs->vassign);
  79                 rs->vassign_size = MAX (rs->next_vreg, 256);
  80                 rs->vassign = g_malloc (rs->vassign_size * sizeof (int));
  81         }
  82
  83         memset (rs->isymbolic, 0, MONO_MAX_IREGS * sizeof (rs->isymbolic [0]));
  84         memset (rs->vassign, -1, sizeof (rs->vassign [0]) * rs->next_vreg);
  85
  86         memset (rs->fsymbolic, 0, MONO_MAX_FREGS * sizeof (rs->fsymbolic [0]));
  87 }
  88
  89 static inline int
  90 mono_regstate_alloc_int (MonoRegState *rs, regmask_t allow)
  91 {
  92         regmask_t mask = allow & rs->ifree_mask;
  93
  94 #if defined(__x86_64__) && defined(__GNUC__)
  95  {
  96         guint64 i;
  97
  98         if (mask == 0)
  99                 return -1;
 100
 101         __asm__("bsfq %1,%0\n\t"
 102                         : "=r" (i) : "rm" (mask));
 103
 104         rs->ifree_mask &= ~ ((regmask_t)1 << i);
 105         return i;
 106  }
 107 #else
 108         int i;
 109
 110         for (i = 0; i < MONO_MAX_IREGS; ++i) {
 111                 if (mask & ((regmask_t)1 << i)) {
 112                         rs->ifree_mask &= ~ ((regmask_t)1 << i);
 113                         return i;
 114                 }
 115         }
 116         return -1;
 117 #endif
 118 }
 119
 120 static inline void
 121 mono_regstate_free_int (MonoRegState *rs, int reg)
 122 {
 123         if (reg >= 0) {
 124                 rs->ifree_mask |= (regmask_t)1 << reg;
 125                 rs->isymbolic [reg] = 0;
 126         }
 127 }
 128
 129 static inline int
 130 mono_regstate_alloc_float (MonoRegState *rs, regmask_t allow)
 131 {
 132         int i;
 133         regmask_t mask = allow & rs->ffree_mask;
 134         for (i = 0; i < MONO_MAX_FREGS; ++i) {
 135                 if (mask & ((regmask_t)1 << i)) {
 136                         rs->ffree_mask &= ~ ((regmask_t)1 << i);
 137                         return i;
 138                 }
 139         }
 140         return -1;
 141 }
 142
 143 static inline void
 144 mono_regstate_free_float (MonoRegState *rs, int reg)
 145 {
 146         if (reg >= 0) {
 147                 rs->ffree_mask |= (regmask_t)1 << reg;
 148                 rs->fsymbolic [reg] = 0;
 149         }
 150 }
 151
 152 static inline int
 153 mono_regstate2_next_long (MonoRegState *rs)
 154 {
 155         int rval = rs->next_vreg;
 156
 157         rs->next_vreg += 2;
 158
 159         return rval;
 160 }
 161
 162 const char*
 163 mono_regname_full (int reg, gboolean fp)
 164 {
 165         if (fp)
 166                 return mono_arch_fregname (reg);
 167         else
 168                 return mono_arch_regname (reg);
 169 }
 170
 171 void
 172 mono_call_inst_add_outarg_reg (MonoCompile *cfg, MonoCallInst *call, int vreg, int hreg, gboolean fp)
 173 {
 174         guint32 regpair;
 175
 176         regpair = (((guint32)hreg) << 24) + vreg;
 177         if (fp) {
 178                 g_assert (vreg >= MONO_MAX_FREGS);
 179                 g_assert (hreg < MONO_MAX_FREGS);
 180                 call->used_fregs |= 1 << hreg;
 181                 call->out_freg_args = g_slist_append_mempool (cfg->mempool, call->out_freg_args, (gpointer)(gssize)(regpair));
 182         } else {
 183                 g_assert (vreg >= MONO_MAX_IREGS);
 184                 g_assert (hreg < MONO_MAX_IREGS);
 185                 call->used_iregs |= 1 << hreg;
 186                 call->out_ireg_args = g_slist_append_mempool (cfg->mempool, call->out_ireg_args, (gpointer)(gssize)(regpair));
 187         }
 188 }
 189
 190 static void
 191 resize_spill_info (MonoCompile *cfg, gboolean fp)
 192 {
 193         MonoSpillInfo *orig_info = fp ? cfg->spill_info_float : cfg->spill_info;
 194         int orig_len = fp ? cfg->spill_info_float_len : cfg->spill_info_len;
 195         int new_len = orig_len ? orig_len * 2 : 16;
 196         MonoSpillInfo *new_info;
 197         int i;
 198
 199         new_info = mono_mempool_alloc (cfg->mempool, sizeof (MonoSpillInfo) * new_len);
 200         if (orig_info)
 201                 memcpy (new_info, orig_info, sizeof (MonoSpillInfo) * orig_len);
 202         for (i = orig_len; i < new_len; ++i)
 203                 new_info [i].offset = -1;
 204
 205         if (!fp) {
 206                 cfg->spill_info = new_info;
 207                 cfg->spill_info_len = new_len;
 208         } else {
 209                 cfg->spill_info_float = new_info;
 210                 cfg->spill_info_float_len = new_len;
 211         }
 212 }
 213
 214 /*
 215  * returns the offset used by spillvar. It allocates a new
 216  * spill variable if necessary.
 217  */
 218 static inline int
 219 mono_spillvar_offset_int (MonoCompile *cfg, int spillvar)
 220 {
 221         MonoSpillInfo *info;
 222
 223 #if defined (__mips__)
 224         g_assert_not_reached();
 225 #endif
 226         if (G_UNLIKELY (spillvar >= cfg->spill_info_len)) {
 227                 resize_spill_info (cfg, FALSE);
 228                 g_assert (spillvar < cfg->spill_info_len);
 229         }
 230
 231         info = &cfg->spill_info [spillvar];
 232         if (info->offset == -1) {
 233                 cfg->stack_offset += sizeof (gpointer) - 1;
 234                 cfg->stack_offset &= ~(sizeof (gpointer) - 1);
 235
 236                 if (cfg->flags & MONO_CFG_HAS_SPILLUP) {
 237                         info->offset = cfg->stack_offset;
 238                         cfg->stack_offset += sizeof (gpointer);
 239                 } else {
 240                         cfg->stack_offset += sizeof (gpointer);
 241                         info->offset = - cfg->stack_offset;
 242                 }
 243         }
 244
 245         return info->offset;
 246 }
 247
 248 /*
 249  * returns the offset used by spillvar. It allocates a new
 250  * spill float variable if necessary.
 251  * (same as mono_spillvar_offset but for float)
 252  */
 253 static inline int
 254 mono_spillvar_offset_float (MonoCompile *cfg, int spillvar)
 255 {
 256         MonoSpillInfo *info;
 257
 258 #if defined (__mips__)
 259         g_assert_not_reached();
 260 #endif
 261         if (G_UNLIKELY (spillvar >= cfg->spill_info_float_len)) {
 262                 resize_spill_info (cfg, TRUE);
 263                 g_assert (spillvar < cfg->spill_info_float_len);
 264         }
 265
 266         info = &cfg->spill_info_float [spillvar];
 267         if (info->offset == -1) {
 268                 cfg->stack_offset += sizeof (double) - 1;
 269                 cfg->stack_offset &= ~(sizeof (double) - 1);
 270
 271                 if (cfg->flags & MONO_CFG_HAS_SPILLUP) {
 272                         info->offset = cfg->stack_offset;
 273                         cfg->stack_offset += sizeof (double);
 274                 } else {
 275                         cfg->stack_offset += sizeof (double);
 276                         info->offset = - cfg->stack_offset;
 277                 }
 278         }
 279
 280         return info->offset;
 281 }
 282
 283 static inline int
 284 mono_spillvar_offset (MonoCompile *cfg, int spillvar, gboolean fp)
 285 {
 286         if (fp)
 287                 return mono_spillvar_offset_float (cfg, spillvar);
 288         else
 289                 return mono_spillvar_offset_int (cfg, spillvar);
 290 }
 291
 292 #if MONO_ARCH_USE_FPSTACK
 293
 294 /*
 295  * Creates a store for spilled floating point items
 296  */
 297 static MonoInst*
 298 create_spilled_store_float (MonoCompile *cfg, int spill, int reg, MonoInst *ins)
 299 {
 300         MonoInst *store;
 301         MONO_INST_NEW (cfg, store, OP_STORER8_MEMBASE_REG);
 302         store->sreg1 = reg;
 303         store->inst_destbasereg = cfg->frame_reg;
 304         store->inst_offset = mono_spillvar_offset_float (cfg, spill);
 305
 306         DEBUG (printf ("SPILLED FLOAT STORE (%d at 0x%08lx(%%sp)) (from %d)\n", spill, (long)store->inst_offset, reg));
 307         return store;
 308 }
 309
 310 /*
 311  * Creates a load for spilled floating point items
 312  */
 313 static MonoInst*
 314 create_spilled_load_float (MonoCompile *cfg, int spill, int reg, MonoInst *ins)
 315 {
 316         MonoInst *load;
 317         MONO_INST_NEW (cfg, load, OP_LOADR8_SPILL_MEMBASE);
 318         load->dreg = reg;
 319         load->inst_basereg = cfg->frame_reg;
 320         load->inst_offset = mono_spillvar_offset_float (cfg, spill);
 321
 322         DEBUG (printf ("SPILLED FLOAT LOAD (%d at 0x%08lx(%%sp)) (from %d)\n", spill, (long)load->inst_offset, reg));
 323         return load;
 324 }
 325
 326 #endif /* MONO_ARCH_USE_FPSTACK */
 327
 328 #define regmask(reg) (((regmask_t)1) << (reg))
 329
 330 #define is_hard_ireg(r) ((r) >= 0 && (r) < MONO_MAX_IREGS)
 331 #define is_hard_freg(r) ((r) >= 0 && (r) < MONO_MAX_FREGS)
 332 #define is_global_ireg(r) (is_hard_ireg ((r)) && (MONO_ARCH_CALLEE_SAVED_REGS & (regmask (r))))
 333 #define is_local_ireg(r) (is_hard_ireg ((r)) && (MONO_ARCH_CALLEE_REGS & (regmask (r))))
 334 #define is_global_freg(r) (is_hard_freg ((r)) && (MONO_ARCH_CALLEE_SAVED_FREGS & (regmask (r))))
 335 #define is_local_freg(r) (is_hard_ireg ((r)) && (MONO_ARCH_CALLEE_FREGS & (regmask (r))))
 336 #define ireg_is_freeable(r) is_local_ireg ((r))
 337 #define freg_is_freeable(r) is_hard_freg ((r))
 338
 339 #define reg_is_freeable(r,fp) ((fp) ? freg_is_freeable ((r)) : ireg_is_freeable ((r)))
 340 #define is_hard_reg(r,fp) ((fp) ? ((r) < MONO_MAX_FREGS) : ((r) < MONO_MAX_IREGS))
 341 #define is_soft_reg(r,fp) (!is_hard_reg((r),(fp)))
 342 #define rassign(cfg,reg,fp) ((cfg)->rs->vassign [(reg)])
 343
 344 #ifdef MONO_ARCH_INST_IS_FLOAT
 345 #define dreg_is_fp(spec)  (MONO_ARCH_INST_IS_FLOAT (spec [MONO_INST_DEST]))
 346 #define sreg1_is_fp(spec) (MONO_ARCH_INST_IS_FLOAT (spec [MONO_INST_SRC1]))
 347 #define sreg2_is_fp(spec) (MONO_ARCH_INST_IS_FLOAT (spec [MONO_INST_SRC2]))
 348 #else
 349 #define sreg1_is_fp(spec) (spec [MONO_INST_SRC1] == 'f')
 350 #define sreg2_is_fp(spec) (spec [MONO_INST_SRC2] == 'f')
 351 #define dreg_is_fp(spec)  (spec [MONO_INST_DEST] == 'f')
 352 #endif
 353
 354 #define sreg1_is_fp_ins(ins) (sreg1_is_fp (ins_get_spec ((ins)->opcode)))
 355 #define sreg2_is_fp_ins(ins) (sreg2_is_fp (ins_get_spec ((ins)->opcode)))
 356 #define dreg_is_fp_ins(ins)  (dreg_is_fp (ins_get_spec ((ins)->opcode)))
 357
 358 #define regpair_reg2_mask(desc,hreg1) ((MONO_ARCH_INST_REGPAIR_REG2 (desc,hreg1) != -1) ? (regmask (MONO_ARCH_INST_REGPAIR_REG2 (desc,hreg1))) : MONO_ARCH_CALLEE_REGS)
 359
 360 #ifdef MONO_ARCH_IS_GLOBAL_IREG
 361 #undef is_global_ireg
 362 #define is_global_ireg(reg) MONO_ARCH_IS_GLOBAL_IREG ((reg))
 363 #endif
 364
 365 typedef struct {
 366         int born_in;
 367         int killed_in;
 368         /* Not (yet) used */
 369         //int last_use;
 370         //int prev_use;
 371 #if MONO_ARCH_USE_FPSTACK
 372         int flags;              /* used to track fp spill/load */
 373 #endif
 374         regmask_t preferred_mask; /* the hreg where the register should be allocated, or 0 */
 375 } RegTrack;
 376
 377 #ifndef DISABLE_LOGGING
 378 void
 379 mono_print_ins (int i, MonoInst *ins)
 380 {
 381         const char *spec = ins_get_spec (ins->opcode);
 382         printf ("\t%-2d %s", i, mono_inst_name (ins->opcode));
 383         if (!spec)
 384                 g_error ("Unknown opcode: %s\n", mono_inst_name (ins->opcode));
 385
 386         if (spec [MONO_INST_DEST]) {
 387                 gboolean fp = dreg_is_fp_ins (ins);
 388                 if (is_soft_reg (ins->dreg, fp)) {
 389                         if (spec [MONO_INST_DEST] == 'b') {
 390                                 if (ins->inst_offset == 0)
 391                                         printf (" [R%d] <-", ins->dreg);
 392                                 else
 393                                         printf (" [R%d + 0x%lx] <-", ins->dreg, (long)ins->inst_offset);
 394                         }
 395                         else
 396                                 printf (" R%d <-", ins->dreg);
 397                 } else if (spec [MONO_INST_DEST] == 'b') {
 398                         if (ins->inst_offset == 0)
 399                                 printf (" [%s] <-", mono_arch_regname (ins->dreg));
 400                         else
 401                                 printf (" [%s + 0x%lx] <-", mono_arch_regname (ins->dreg), (long)ins->inst_offset);
 402                 } else
 403                         printf (" %s <-", mono_regname_full (ins->dreg, fp));
 404         }
 405         if (spec [MONO_INST_SRC1]) {
 406                 gboolean fp = (spec [MONO_INST_SRC1] == 'f');
 407                 if (is_soft_reg (ins->sreg1, fp))
 408                         printf (" R%d", ins->sreg1);
 409                 else if (spec [MONO_INST_SRC1] == 'b')
 410                         printf (" [%s + 0x%lx]", mono_arch_regname (ins->sreg1), (long)ins->inst_offset);
 411                 else
 412                         printf (" %s", mono_regname_full (ins->sreg1, fp));
 413         }
 414         if (spec [MONO_INST_SRC2]) {
 415                 gboolean fp = (spec [MONO_INST_SRC2] == 'f');
 416                 if (is_soft_reg (ins->sreg2, fp))
 417                         printf (" R%d", ins->sreg2);
 418                 else
 419                         printf (" %s", mono_regname_full (ins->sreg2, fp));
 420         }
 421         if (spec [MONO_INST_CLOB])
 422                 printf (" clobbers: %c", spec [MONO_INST_CLOB]);
 423         printf ("\n");
 424 }
 425
 426 static void
 427 print_regtrack (RegTrack *t, int num)
 428 {
 429         int i;
 430         char buf [32];
 431         const char *r;
 432
 433         for (i = 0; i < num; ++i) {
 434                 if (!t [i].born_in)
 435                         continue;
 436                 if (i >= MONO_MAX_IREGS) {
 437                         g_snprintf (buf, sizeof(buf), "R%d", i);
 438                         r = buf;
 439                 } else
 440                         r = mono_arch_regname (i);
 441                 printf ("liveness: %s [%d - %d]\n", r, t [i].born_in, t[i].killed_in);
 442         }
 443 }
 444 #endif /* DISABLE_LOGGING */
 445
 446 typedef struct InstList InstList;
 447
 448 struct InstList {
 449         InstList *prev;
 450         InstList *next;
 451         MonoInst *data;
 452 };
 453
 454 static inline InstList*
 455 inst_list_prepend (guint8 *mem, InstList *list, MonoInst *data)
 456 {
 457         InstList *item = (InstList*)(gpointer)mem;
 458         item->data = data;
 459         item->prev = NULL;
 460         item->next = list;
 461         if (list)
 462                 list->prev = item;
 463         return item;
 464 }
 465
 466 static inline void
 467 insert_before_ins (MonoInst *ins, InstList *item, MonoInst* to_insert)
 468 {
 469         MonoInst *prev;
 470
 471         /*
 472          * If this function is called multiple times, the new instructions are inserted
 473          * in the proper order.
 474          */
 475
 476         if (item->next) {
 477                 prev = item->next->data;
 478
 479                 while (prev->next != ins)
 480                         prev = prev->next;
 481                 to_insert->next = ins;
 482                 prev->next = to_insert;
 483         } else {
 484                 to_insert->next = ins;
 485         }
 486
 487         /*
 488          * insert_after_ins insert the new instruction before item->data, so
 489          * we have to modify it to point to the first of the prepended instructions.
 490          */
 491         if (item->data == ins)
 492                 item->data = to_insert;
 493 }
 494
 495 static inline void
 496 insert_after_ins (MonoInst *ins, InstList *item, MonoInst* to_insert)
 497 {
 498         if (item->prev) {
 499                 while (ins->next != item->prev->data)
 500                         ins = ins->next;
 501         }
 502         to_insert->next = ins->next;
 503         ins->next = to_insert;
 504 }
 505
 506 /*
 507  * Force the spilling of the variable in the symbolic register 'reg'.
 508  */
 509 static int
 510 get_register_force_spilling (MonoCompile *cfg, InstList *item, MonoInst *ins, int reg, gboolean fp)
 511 {
 512         MonoInst *load;
 513         int i, sel, spill;
 514         int *assign, *symbolic;
 515
 516         assign = cfg->rs->vassign;
 517         if (fp)
 518                 symbolic = cfg->rs->fsymbolic;
 519         else
 520                 symbolic = cfg->rs->isymbolic;
 521
 522         sel = cfg->rs->vassign [reg];
 523         /*i = cfg->rs->isymbolic [sel];
 524         g_assert (i == reg);*/
 525         i = reg;
 526         spill = ++cfg->spill_count;
 527         assign [i] = -spill - 1;
 528         if (fp)
 529                 mono_regstate_free_float (cfg->rs, sel);
 530         else
 531                 mono_regstate_free_int (cfg->rs, sel);
 532         /* we need to create a spill var and insert a load to sel after the current instruction */
 533         if (fp)
 534                 MONO_INST_NEW (cfg, load, OP_LOADR8_MEMBASE);
 535         else
 536                 MONO_INST_NEW (cfg, load, OP_LOAD_MEMBASE);
 537         load->dreg = sel;
 538         load->inst_basereg = cfg->frame_reg;
 539         load->inst_offset = mono_spillvar_offset (cfg, spill, fp);
 540         insert_after_ins (ins, item, load);
 541         DEBUG (printf ("SPILLED LOAD (%d at 0x%08lx(%%ebp)) R%d (freed %s)\n", spill, (long)load->inst_offset, i, mono_regname_full (sel, fp)));
 542         if (fp)
 543                 i = mono_regstate_alloc_float (cfg->rs, regmask (sel));
 544         else
 545                 i = mono_regstate_alloc_int (cfg->rs, regmask (sel));
 546         g_assert (i == sel);
 547
 548         return sel;
 549 }
 550
 551 /* This isn't defined on older glib versions and on some platforms */
 552 #ifndef G_GUINT64_FORMAT
 553 #define G_GUINT64_FORMAT "ul"
 554 #endif
 555
 556 static int
 557 get_register_spilling (MonoCompile *cfg, InstList *item, MonoInst *ins, regmask_t regmask, int reg, gboolean fp)
 558 {
 559         MonoInst *load;
 560         int i, sel, spill;
 561         int *assign, *symbolic;
 562
 563         assign = cfg->rs->vassign;
 564         if (fp)
 565                 symbolic = cfg->rs->fsymbolic;
 566         else
 567                 symbolic = cfg->rs->isymbolic;
 568
 569         DEBUG (printf ("\tstart regmask to assign R%d: 0x%08" G_GUINT64_FORMAT " (R%d <- R%d R%d)\n", reg, (guint64)regmask, ins->dreg, ins->sreg1, ins->sreg2));
 570         /* exclude the registers in the current instruction */
 571         if ((sreg1_is_fp_ins (ins) == fp) && (reg != ins->sreg1) && (reg_is_freeable (ins->sreg1, fp) || (is_soft_reg (ins->sreg1, fp) && rassign (cfg, ins->sreg1, fp) >= 0))) {
 572                 if (is_soft_reg (ins->sreg1, fp))
 573                         regmask &= ~ (regmask (rassign (cfg, ins->sreg1, fp)));
 574                 else
 575                         regmask &= ~ (regmask (ins->sreg1));
 576                 DEBUG (printf ("\t\texcluding sreg1 %s\n", mono_regname_full (ins->sreg1, fp)));
 577         }
 578         if ((sreg2_is_fp_ins (ins) == fp) && (reg != ins->sreg2) && (reg_is_freeable (ins->sreg2, fp) || (is_soft_reg (ins->sreg2, fp) && rassign (cfg, ins->sreg2, fp) >= 0))) {
 579                 if (is_soft_reg (ins->sreg2, fp))
 580                         regmask &= ~ (regmask (rassign (cfg, ins->sreg2, fp)));
 581                 else
 582                         regmask &= ~ (regmask (ins->sreg2));
 583                 DEBUG (printf ("\t\texcluding sreg2 %s %d\n", mono_regname_full (ins->sreg2, fp), ins->sreg2));
 584         }
 585         if ((dreg_is_fp_ins (ins) == fp) && (reg != ins->dreg) && reg_is_freeable (ins->dreg, fp)) {
 586                 regmask &= ~ (regmask (ins->dreg));
 587                 DEBUG (printf ("\t\texcluding dreg %s\n", mono_regname_full (ins->dreg, fp)));
 588         }
 589
 590         DEBUG (printf ("\t\tavailable regmask: 0x%08" G_GUINT64_FORMAT "\n", (guint64)regmask));
 591         g_assert (regmask); /* need at least a register we can free */
 592         sel = -1;
 593         /* we should track prev_use and spill the register that's farther */
 594         if (fp) {
 595                 for (i = 0; i < MONO_MAX_FREGS; ++i) {
 596                         if (regmask & (regmask (i))) {
 597                                 sel = i;
 598                                 DEBUG (printf ("\t\tselected register %s has assignment %d\n", mono_arch_fregname (sel), cfg->rs->fsymbolic [sel]));
 599                                 break;
 600                         }
 601                 }
 602
 603                 i = cfg->rs->fsymbolic [sel];
 604                 spill = ++cfg->spill_count;
 605                 cfg->rs->vassign [i] = -spill - 1;
 606                 mono_regstate_free_float (cfg->rs, sel);
 607         }
 608         else {
 609                 for (i = 0; i < MONO_MAX_IREGS; ++i) {
 610                         if (regmask & (regmask (i))) {
 611                                 sel = i;
 612                                 DEBUG (printf ("\t\tselected register %s has assignment %d\n", mono_arch_regname (sel), cfg->rs->isymbolic [sel]));
 613                                 break;
 614                         }
 615                 }
 616
 617                 i = cfg->rs->isymbolic [sel];
 618                 spill = ++cfg->spill_count;
 619                 cfg->rs->vassign [i] = -spill - 1;
 620                 mono_regstate_free_int (cfg->rs, sel);
 621         }
 622
 623         /* we need to create a spill var and insert a load to sel after the current instruction */
 624         MONO_INST_NEW (cfg, load, fp ? OP_LOADR8_MEMBASE : OP_LOAD_MEMBASE);
 625         load->dreg = sel;
 626         load->inst_basereg = cfg->frame_reg;
 627         load->inst_offset = mono_spillvar_offset (cfg, spill, fp);
 628         insert_after_ins (ins, item, load);
 629         DEBUG (printf ("\tSPILLED LOAD (%d at 0x%08lx(%%ebp)) R%d (freed %s)\n", spill, (long)load->inst_offset, i, mono_regname_full (sel, fp)));
 630         if (fp)
 631                 i = mono_regstate_alloc_float (cfg->rs, regmask (sel));
 632         else
 633                 i = mono_regstate_alloc_int (cfg->rs, regmask (sel));
 634         g_assert (i == sel);
 635
 636         return sel;
 637 }
 638
 639 static void
 640 free_up_ireg (MonoCompile *cfg, InstList *item, MonoInst *ins, int hreg)
 641 {
 642         if (!(cfg->rs->ifree_mask & (regmask (hreg)))) {
 643                 DEBUG (printf ("\tforced spill of R%d\n", cfg->rs->isymbolic [hreg]));
 644                 get_register_force_spilling (cfg, item, ins, cfg->rs->isymbolic [hreg], FALSE);
 645                 mono_regstate_free_int (cfg->rs, hreg);
 646         }
 647 }
 648
 649 static void
 650 free_up_reg (MonoCompile *cfg, InstList *item, MonoInst *ins, int hreg, gboolean fp)
 651 {
 652         if (fp) {
 653                 if (!(cfg->rs->ffree_mask & (regmask (hreg)))) {
 654                         DEBUG (printf ("\tforced spill of R%d\n", cfg->rs->isymbolic [hreg]));
 655                         get_register_force_spilling (cfg, item, ins, cfg->rs->isymbolic [hreg], fp);
 656                         mono_regstate_free_float (cfg->rs, hreg);
 657                 }
 658         }
 659         else {
 660                 if (!(cfg->rs->ifree_mask & (regmask (hreg)))) {
 661                         DEBUG (printf ("\tforced spill of R%d\n", cfg->rs->isymbolic [hreg]));
 662                         get_register_force_spilling (cfg, item, ins, cfg->rs->isymbolic [hreg], fp);
 663                         mono_regstate_free_int (cfg->rs, hreg);
 664                 }
 665         }
 666 }
 667
 668 static MonoInst*
 669 create_copy_ins (MonoCompile *cfg, int dest, int src, MonoInst *ins, const unsigned char *ip, gboolean fp)
 670 {
 671         MonoInst *copy;
 672
 673         if (fp)
 674                 MONO_INST_NEW (cfg, copy, OP_FMOVE);
 675         else
 676                 MONO_INST_NEW (cfg, copy, OP_MOVE);
 677
 678         copy->dreg = dest;
 679         copy->sreg1 = src;
 680         copy->cil_code = ip;
 681         if (ins) {
 682                 copy->next = ins->next;
 683                 copy->cil_code = ins->cil_code;
 684                 ins->next = copy;
 685         }
 686         DEBUG (printf ("\tforced copy from %s to %s\n", mono_regname_full (src, fp), mono_regname_full (dest, fp)));
 687         return copy;
 688 }
 689
 690 static MonoInst*
 691 create_spilled_store (MonoCompile *cfg, int spill, int reg, int prev_reg, MonoInst *ins, gboolean fp)
 692 {
 693         MonoInst *store;
 694         MONO_INST_NEW (cfg, store, fp ? OP_STORER8_MEMBASE_REG : OP_STORE_MEMBASE_REG);
 695         store->sreg1 = reg;
 696         store->inst_destbasereg = cfg->frame_reg;
 697         store->inst_offset = mono_spillvar_offset (cfg, spill, fp);
 698         if (ins) {
 699                 store->next = ins->next;
 700                 ins->next = store;
 701         }
 702         DEBUG (printf ("\tSPILLED STORE (%d at 0x%08lx(%%ebp)) R%d (from %s)\n", spill, (long)store->inst_offset, prev_reg, mono_regname_full (reg, fp)));
 703         return store;
 704 }
 705
 706 /* flags used in reginfo->flags */
 707 enum {
 708         MONO_FP_NEEDS_LOAD_SPILL        = regmask (0),
 709         MONO_FP_NEEDS_SPILL                     = regmask (1),
 710         MONO_FP_NEEDS_LOAD                      = regmask (2)
 711 };
 712
 713 static inline int
 714 alloc_int_reg (MonoCompile *cfg, InstList *tmp, MonoInst *ins, regmask_t dest_mask, int sym_reg, RegTrack *info)
 715 {
 716         int val;
 717
 718         if (info && info->preferred_mask) {
 719                 val = mono_regstate_alloc_int (cfg->rs, info->preferred_mask & dest_mask);
 720                 if (val >= 0) {
 721                         DEBUG (printf ("\tallocated preferred reg R%d to %s\n", sym_reg, mono_arch_regname (val)));
 722                         return val;
 723                 }
 724         }
 725
 726         val = mono_regstate_alloc_int (cfg->rs, dest_mask);
 727         if (val < 0)
 728                 val = get_register_spilling (cfg, tmp, ins, dest_mask, sym_reg, FALSE);
 729
 730         return val;
 731 }
 732
 733 static inline int
 734 alloc_float_reg (MonoCompile *cfg, InstList *tmp, MonoInst *ins, regmask_t dest_mask, int sym_reg)
 735 {
 736         int val;
 737
 738         val = mono_regstate_alloc_float (cfg->rs, dest_mask);
 739
 740         if (val < 0) {
 741                 val = get_register_spilling (cfg, tmp, ins, dest_mask, sym_reg, TRUE);
 742         }
 743
 744         return val;
 745 }
 746
 747 static inline int
 748 alloc_reg (MonoCompile *cfg, InstList *tmp, MonoInst *ins, regmask_t dest_mask, int sym_reg, RegTrack *info, gboolean fp)
 749 {
 750         if (fp)
 751                 return alloc_float_reg (cfg, tmp, ins, dest_mask, sym_reg);
 752         else
 753                 return alloc_int_reg (cfg, tmp, ins, dest_mask, sym_reg, info);
 754 }
 755
 756 static inline void
 757 assign_reg (MonoCompile *cfg, MonoRegState *rs, int reg, int hreg, gboolean fp)
 758 {
 759         if (fp) {
 760                 g_assert (reg >= MONO_MAX_FREGS);
 761                 g_assert (hreg < MONO_MAX_FREGS);
 762                 g_assert (! is_global_freg (hreg));
 763
 764                 rs->vassign [reg] = hreg;
 765                 rs->fsymbolic [hreg] = reg;
 766                 rs->ffree_mask &= ~ (regmask (hreg));
 767         }
 768         else {
 769                 g_assert (reg >= MONO_MAX_IREGS);
 770                 g_assert (hreg < MONO_MAX_IREGS);
 771 #ifndef __arm__
 772                 /* this seems to trigger a gcc compilation bug sometime (hreg is 0) */
 773                 g_assert (! is_global_ireg (hreg));
 774 #endif
 775
 776                 rs->vassign [reg] = hreg;
 777                 rs->isymbolic [hreg] = reg;
 778                 rs->ifree_mask &= ~ (regmask (hreg));
 779         }
 780 }
 781
 782 static inline void
 783 assign_ireg (MonoCompile *cfg, MonoRegState *rs, int reg, int hreg)
 784 {
 785         assign_reg (cfg, rs, reg, hreg, FALSE);
 786 }
 787
 788 /*
 789  * Local register allocation.
 790  * We first scan the list of instructions and we save the liveness info of
 791  * each register (when the register is first used, when it's value is set etc.).
 792  * We also reverse the list of instructions (in the InstList list) because assigning
 793  * registers backwards allows for more tricks to be used.
 794  */
 795 void
 796 mono_local_regalloc (MonoCompile *cfg, MonoBasicBlock *bb)
 797 {
 798         MonoInst *ins;
 799         MonoRegState *rs = cfg->rs;
 800         int i, val, fpcount, ins_count;
 801         RegTrack *reginfo;
 802         InstList *tmp, *reversed = NULL;
 803         const char *spec;
 804         GList *fspill_list = NULL;
 805         gboolean fp;
 806         int fspill = 0;
 807         guint8 *inst_list, *mem;
 808 #if MONO_ARCH_USE_FPSTACK
 809         gboolean need_fpstack = use_fpstack;
 810 #endif
 811
 812         if (!bb->code)
 813                 return;
 814
 815         rs->next_vreg = bb->max_vreg;
 816         mono_regstate_assign (rs);
 817
 818         rs->ifree_mask = MONO_ARCH_CALLEE_REGS;
 819         rs->ffree_mask = MONO_ARCH_CALLEE_FREGS;
 820
 821         if (use_fpstack)
 822                 rs->ffree_mask = 0xff & ~(regmask (MONO_ARCH_FPSTACK_SIZE));
 823
 824         ins = bb->code;
 825
 826         /*if (cfg->opt & MONO_OPT_COPYPROP)
 827                 local_copy_prop (cfg, ins);*/
 828
 829         if (cfg->reginfo && cfg->reginfo_len < rs->next_vreg) {
 830                 cfg->reginfo = NULL;
 831         }
 832         reginfo = cfg->reginfo;
 833         if (!reginfo) {
 834                 cfg->reginfo_len = MAX (256, rs->next_vreg * 2);
 835                 reginfo = cfg->reginfo = mono_mempool_alloc (cfg->mempool, sizeof (RegTrack) * cfg->reginfo_len);
 836         }
 837         else
 838                 g_assert (cfg->reginfo_len >= rs->next_vreg);
 839
 840         memset (reginfo, 0, rs->next_vreg * sizeof (RegTrack));
 841
 842         ins_count = 0;
 843         for (ins = bb->code; ins; ins = ins->next) {
 844                 ins_count ++;
 845         }
 846
 847         if (cfg->reverse_inst_list && (cfg->reverse_inst_list_len < ins_count)) {
 848                 cfg->reverse_inst_list = NULL;
 849         }
 850
 851         inst_list = cfg->reverse_inst_list;
 852         if (!inst_list) {
 853                 cfg->reverse_inst_list_len = MAX (ins_count, 1024);
 854                 inst_list = cfg->reverse_inst_list = mono_mempool_alloc (cfg->mempool, cfg->reverse_inst_list_len * sizeof (InstList));
 855         }
 856         mem = inst_list;
 857
 858         i = 1;
 859         fpcount = 0;
 860         DEBUG (printf ("\nLOCAL REGALLOC: BASIC BLOCK: %d\n", bb->block_num));
 861         /* forward pass on the instructions to collect register liveness info */
 862         for (ins = bb->code; ins; ins = ins->next) {
 863                 spec = ins_get_spec (ins->opcode);
 864
 865                 if (G_UNLIKELY (spec == MONO_ARCH_CPU_SPEC)) {
 866                         g_error ("Opcode '%s' missing from machine description file.", mono_inst_name (ins->opcode));
 867                 }
 868
 869                 DEBUG (mono_print_ins (i, ins));
 870
 871                 /*
 872                  * TRACK FP STACK
 873                  */
 874 #if MONO_ARCH_USE_FPSTACK
 875                 if (need_fpstack) {
 876                         GList *spill;
 877
 878                         if (spec [MONO_INST_SRC1] == 'f') {
 879                                 spill = g_list_first (fspill_list);
 880                                 if (spill && fpcount < MONO_ARCH_FPSTACK_SIZE) {
 881                                         reginfo [ins->sreg1].flags |= MONO_FP_NEEDS_LOAD;
 882                                         fspill_list = g_list_remove (fspill_list, spill->data);
 883                                 } else
 884                                         fpcount--;
 885                         }
 886
 887                         if (spec [MONO_INST_SRC2] == 'f') {
 888                                 spill = g_list_first (fspill_list);
 889                                 if (spill) {
 890                                         reginfo [ins->sreg2].flags |= MONO_FP_NEEDS_LOAD;
 891                                         fspill_list = g_list_remove (fspill_list, spill->data);
 892                                         if (fpcount >= MONO_ARCH_FPSTACK_SIZE) {
 893                                                 fspill++;
 894                                                 fspill_list = g_list_prepend (fspill_list, GINT_TO_POINTER(fspill));
 895                                                 reginfo [ins->sreg2].flags |= MONO_FP_NEEDS_LOAD_SPILL;
 896                                         }
 897                                 } else
 898                                         fpcount--;
 899                         }
 900
 901                         if (dreg_is_fp (spec)) {
 902                                 if (use_fpstack && (spec [MONO_INST_CLOB] != 'm')) {
 903                                         if (fpcount >= MONO_ARCH_FPSTACK_SIZE) {
 904                                                 reginfo [ins->dreg].flags |= MONO_FP_NEEDS_SPILL;
 905                                                 fspill++;
 906                                                 fspill_list = g_list_prepend (fspill_list, GINT_TO_POINTER(fspill));
 907                                                 fpcount--;
 908                                         }
 909                                         fpcount++;
 910                                 }
 911                         }
 912                 }
 913 #endif
 914
 915                 if (spec [MONO_INST_SRC1]) {
 916                         //reginfo [ins->sreg1].prev_use = reginfo [ins->sreg1].last_use;
 917                         //reginfo [ins->sreg1].last_use = i;
 918                         if (MONO_ARCH_INST_IS_REGPAIR (spec [MONO_INST_SRC2])) {
 919                                 /* The virtual register is allocated sequentially */
 920                                 //reginfo [ins->sreg1 + 1].prev_use = reginfo [ins->sreg1 + 1].last_use;
 921                                 //reginfo [ins->sreg1 + 1].last_use = i;
 922                                 if (reginfo [ins->sreg1 + 1].born_in == 0 || reginfo [ins->sreg1 + 1].born_in > i)
 923                                         reginfo [ins->sreg1 + 1].born_in = i;
 924                         }
 925                 } else {
 926                         ins->sreg1 = -1;
 927                 }
 928                 if (spec [MONO_INST_SRC2]) {
 929                         //reginfo [ins->sreg2].prev_use = reginfo [ins->sreg2].last_use;
 930                         //reginfo [ins->sreg2].last_use = i;
 931                         if (MONO_ARCH_INST_IS_REGPAIR (spec [MONO_INST_SRC2])) {
 932                                 /* The virtual register is allocated sequentially */
 933                                 //reginfo [ins->sreg2 + 1].prev_use = reginfo [ins->sreg2 + 1].last_use;
 934                                 //reginfo [ins->sreg2 + 1].last_use = i;
 935                                 if (reginfo [ins->sreg2 + 1].born_in == 0 || reginfo [ins->sreg2 + 1].born_in > i)
 936                                         reginfo [ins->sreg2 + 1].born_in = i;
 937                         }
 938                 } else {
 939                         ins->sreg2 = -1;
 940                 }
 941                 if (spec [MONO_INST_DEST]) {
 942                         int dest_dreg;
 943
 944                         if (spec [MONO_INST_DEST] != 'b') /* it's not just a base register */
 945                                 reginfo [ins->dreg].killed_in = i;
 946                         //reginfo [ins->dreg].prev_use = reginfo [ins->dreg].last_use;
 947                         //reginfo [ins->dreg].last_use = i;
 948                         if (reginfo [ins->dreg].born_in == 0 || reginfo [ins->dreg].born_in > i)
 949                                 reginfo [ins->dreg].born_in = i;
 950
 951                         dest_dreg = MONO_ARCH_INST_FIXED_REG (spec [MONO_INST_DEST]);
 952                         if (dest_dreg != -1)
 953                                 reginfo [ins->dreg].preferred_mask = (regmask (dest_dreg));
 954
 955                         if (MONO_ARCH_INST_IS_REGPAIR (spec [MONO_INST_DEST])) {
 956                                 /* The virtual register is allocated sequentially */
 957                                 //reginfo [ins->dreg + 1].prev_use = reginfo [ins->dreg + 1].last_use;
 958                                 //reginfo [ins->dreg + 1].last_use = i;
 959                                 if (reginfo [ins->dreg + 1].born_in == 0 || reginfo [ins->dreg + 1].born_in > i)
 960                                         reginfo [ins->dreg + 1].born_in = i;
 961                                 if (MONO_ARCH_INST_REGPAIR_REG2 (spec [MONO_INST_DEST], -1) != -1)
 962                                         reginfo [ins->dreg + 1].preferred_mask = regpair_reg2_mask (spec [MONO_INST_DEST], -1);
 963                         }
 964                 } else {
 965                         ins->dreg = -1;
 966                 }
 967
 968                 if (spec [MONO_INST_CLOB] == 'c') {
 969                         /* A call instruction implicitly uses all registers in call->out_ireg_args */
 970
 971                         MonoCallInst *call = (MonoCallInst*)ins;
 972                         GSList *list;
 973
 974                         list = call->out_ireg_args;
 975                         if (list) {
 976                                 while (list) {
 977                                         guint32 regpair;
 978                                         int reg, hreg;
 979
 980                                         regpair = (guint32)(gssize)(list->data);
 981                                         hreg = regpair >> 24;
 982                                         reg = regpair & 0xffffff;
 983
 984                                         //reginfo [reg].prev_use = reginfo [reg].last_use;
 985                                         //reginfo [reg].last_use = i;
 986
 987                                         list = g_slist_next (list);
 988                                 }
 989                         }
 990
 991                         list = call->out_freg_args;
 992                         if (!use_fpstack && list) {
 993                                 while (list) {
 994                                         guint32 regpair;
 995                                         int reg, hreg;
 996
 997                                         regpair = (guint32)(gssize)(list->data);
 998                                         hreg = regpair >> 24;
 999                                         reg = regpair & 0xffffff;
1000
1001                                         //reginfo [reg].prev_use = reginfo [reg].last_use;
1002                                         //reginfo [reg].last_use = i;
1003
1004                                         list = g_slist_next (list);
1005                                 }
1006                         }
1007                 }
1008
1009                 reversed = inst_list_prepend (mem, reversed, ins);
1010                 mem += sizeof (InstList);
1011                 ++i;
1012         }
1013
1014         // todo: check if we have anything left on fp stack, in verify mode?
1015         fspill = 0;
1016
1017         DEBUG (print_regtrack (reginfo, rs->next_vreg));
1018         tmp = reversed;
1019         while (tmp) {
1020                 int prev_dreg, prev_sreg1, prev_sreg2, clob_dreg;
1021                 int dest_dreg, dest_sreg1, dest_sreg2, clob_reg;
1022                 int dreg_high, sreg1_high;
1023                 regmask_t dreg_mask, sreg1_mask, sreg2_mask, mask;
1024                 regmask_t dreg_fixed_mask, sreg1_fixed_mask, sreg2_fixed_mask;
1025                 const unsigned char *ip;
1026                 --i;
1027                 ins = tmp->data;
1028                 spec = ins_get_spec (ins->opcode);
1029                 prev_dreg = -1;
1030                 prev_sreg2 = -1;
1031                 clob_dreg = -1;
1032                 clob_reg = -1;
1033                 dest_dreg = -1;
1034                 dest_sreg1 = -1;
1035                 dest_sreg2 = -1;
1036                 prev_sreg1 = -1;
1037                 dreg_high = -1;
1038                 sreg1_high = -1;
1039                 dreg_mask = dreg_is_fp (spec) ? MONO_ARCH_CALLEE_FREGS : MONO_ARCH_CALLEE_REGS;
1040                 sreg1_mask = sreg1_is_fp (spec) ? MONO_ARCH_CALLEE_FREGS : MONO_ARCH_CALLEE_REGS;
1041                 sreg2_mask = sreg2_is_fp (spec) ? MONO_ARCH_CALLEE_FREGS : MONO_ARCH_CALLEE_REGS;
1042
1043                 DEBUG (printf ("processing:"));
1044                 DEBUG (mono_print_ins (i, ins));
1045
1046                 ip = ins->cil_code;
1047
1048                 /*
1049                  * FIXED REGS
1050                  */
1051                 dest_sreg1 = MONO_ARCH_INST_FIXED_REG (spec [MONO_INST_SRC1]);
1052                 dest_sreg2 = MONO_ARCH_INST_FIXED_REG (spec [MONO_INST_SRC2]);
1053                 dest_dreg = MONO_ARCH_INST_FIXED_REG (spec [MONO_INST_DEST]);
1054                 clob_reg = MONO_ARCH_INST_FIXED_REG (spec [MONO_INST_CLOB]);
1055                 sreg2_mask &= ~ (MONO_ARCH_INST_SREG2_MASK (spec));
1056
1057 #ifdef MONO_ARCH_INST_FIXED_MASK
1058                 sreg1_fixed_mask = MONO_ARCH_INST_FIXED_MASK (spec [MONO_INST_SRC1]);
1059                 sreg2_fixed_mask = MONO_ARCH_INST_FIXED_MASK (spec [MONO_INST_SRC2]);
1060                 dreg_fixed_mask = MONO_ARCH_INST_FIXED_MASK (spec [MONO_INST_DEST]);
1061 #else
1062                 sreg1_fixed_mask = sreg2_fixed_mask = dreg_fixed_mask = 0;
1063 #endif
1064
1065                 /*
1066                  * TRACK FP STACK
1067                  */
1068 #if MONO_ARCH_USE_FPSTACK
1069                 if (need_fpstack && (spec [MONO_INST_CLOB] != 'm')) {
1070                         if (dreg_is_fp (spec)) {
1071                                 if (reginfo [ins->dreg].flags & MONO_FP_NEEDS_SPILL) {
1072                                         GList *spill_node;
1073                                         MonoInst *store;
1074                                         spill_node = g_list_first (fspill_list);
1075                                         g_assert (spill_node);
1076
1077                                         store = create_spilled_store_float (cfg, GPOINTER_TO_INT (spill_node->data), ins->dreg, ins);
1078                                         insert_before_ins (ins, tmp, store);
1079                                         fspill_list = g_list_remove (fspill_list, spill_node->data);
1080                                         fspill--;
1081                                 }
1082                         }
1083
1084                         if (spec [MONO_INST_SRC1] == 'f') {
1085                                 if (reginfo [ins->sreg1].flags & MONO_FP_NEEDS_LOAD) {
1086                                         MonoInst *load;
1087                                         MonoInst *store = NULL;
1088
1089                                         if (reginfo [ins->sreg1].flags & MONO_FP_NEEDS_LOAD_SPILL) {
1090                                                 GList *spill_node;
1091                                                 spill_node = g_list_first (fspill_list);
1092                                                 g_assert (spill_node);
1093
1094                                                 store = create_spilled_store_float (cfg, GPOINTER_TO_INT (spill_node->data), ins->sreg1, ins);
1095                                                 fspill_list = g_list_remove (fspill_list, spill_node->data);
1096                                         }
1097
1098                                         fspill++;
1099                                         fspill_list = g_list_prepend (fspill_list, GINT_TO_POINTER(fspill));
1100                                         load = create_spilled_load_float (cfg, fspill, ins->sreg1, ins);
1101                                         insert_before_ins (ins, tmp, load);
1102                                         if (store)
1103                                                 insert_before_ins (load, tmp, store);
1104                                 }
1105                         }
1106
1107                         if (spec [MONO_INST_SRC2] == 'f') {
1108                                 if (reginfo [ins->sreg2].flags & MONO_FP_NEEDS_LOAD) {
1109                                         MonoInst *load;
1110                                         MonoInst *store = NULL;
1111
1112                                         if (reginfo [ins->sreg2].flags & MONO_FP_NEEDS_LOAD_SPILL) {
1113                                                 GList *spill_node;
1114
1115                                                 spill_node = g_list_first (fspill_list);
1116                                                 g_assert (spill_node);
1117                                                 if (spec [MONO_INST_SRC1] == 'f' && (reginfo [ins->sreg2].flags & MONO_FP_NEEDS_LOAD_SPILL))
1118                                                         spill_node = g_list_next (spill_node);
1119
1120                                                 store = create_spilled_store_float (cfg, GPOINTER_TO_INT (spill_node->data), ins->sreg2, ins);
1121                                                 fspill_list = g_list_remove (fspill_list, spill_node->data);
1122                                         }
1123
1124                                         fspill++;
1125                                         fspill_list = g_list_prepend (fspill_list, GINT_TO_POINTER(fspill));
1126                                         load = create_spilled_load_float (cfg, fspill, ins->sreg2, ins);
1127                                         insert_before_ins (ins, tmp, load);
1128                                         if (store)
1129                                                 insert_before_ins (load, tmp, store);
1130                                 }
1131                         }
1132                 }
1133 #endif
1134
1135                 /*
1136                  * TRACK FIXED SREG2
1137                  */
1138                 if (dest_sreg2 != -1) {
1139                         if (rs->ifree_mask & (regmask (dest_sreg2))) {
1140                                 if (is_global_ireg (ins->sreg2)) {
1141                                         /* Argument already in hard reg, need to copy */
1142                                         MonoInst *copy = create_copy_ins (cfg, dest_sreg2, ins->sreg2, NULL, ip, FALSE);
1143                                         insert_before_ins (ins, tmp, copy);
1144                                 }
1145                                 else {
1146                                         val = rs->vassign [ins->sreg2];
1147                                         if (val == -1) {
1148                                                 DEBUG (printf ("\tshortcut assignment of R%d to %s\n", ins->sreg2, mono_arch_regname (dest_sreg2)));
1149                                                 assign_reg (cfg, rs, ins->sreg2, dest_sreg2, FALSE);
1150                                         } else if (val < -1) {
1151                                                 /* FIXME: */
1152                                                 g_assert_not_reached ();
1153                                         } else {
1154                                                 /* Argument already in hard reg, need to copy */
1155                                                 MonoInst *copy = create_copy_ins (cfg, dest_sreg2, val, NULL, ip, FALSE);
1156                                                 insert_before_ins (ins, tmp, copy);
1157                                         }
1158                                 }
1159                         } else {
1160                                 int need_spill = TRUE;
1161
1162                                 dreg_mask &= ~ (regmask (dest_sreg2));
1163                                 sreg1_mask &= ~ (regmask (dest_sreg2));
1164
1165                                 /*
1166                                  * First check if dreg is assigned to dest_sreg2, since we
1167                                  * can't spill a dreg.
1168                                  */
1169                                 val = rs->vassign [ins->dreg];
1170                                 if (val == dest_sreg2 && ins->dreg != ins->sreg2) {
1171                                         /*
1172                                          * the destination register is already assigned to
1173                                          * dest_sreg2: we need to allocate another register for it
1174                                          * and then copy from this to dest_sreg2.
1175                                          */
1176                                         int new_dest;
1177                                         new_dest = alloc_int_reg (cfg, tmp, ins, dreg_mask, ins->dreg, &reginfo [ins->dreg]);
1178                                         g_assert (new_dest >= 0);
1179                                         DEBUG (printf ("\tchanging dreg R%d to %s from %s\n", ins->dreg, mono_arch_regname (new_dest), mono_arch_regname (dest_sreg2)));
1180
1181                                         prev_dreg = ins->dreg;
1182                                         assign_ireg (cfg, rs, ins->dreg, new_dest);
1183                                         clob_dreg = ins->dreg;
1184                                         create_copy_ins (cfg, dest_sreg2, new_dest, ins, ip, FALSE);
1185                                         mono_regstate_free_int (rs, dest_sreg2);
1186                                         need_spill = FALSE;
1187                                 }
1188
1189                                 if (is_global_ireg (ins->sreg2)) {
1190                                         MonoInst *copy = create_copy_ins (cfg, dest_sreg2, ins->sreg2, NULL, ip, FALSE);
1191                                         insert_before_ins (ins, tmp, copy);
1192                                 }
1193                                 else {
1194                                         val = rs->vassign [ins->sreg2];
1195                                         if (val == dest_sreg2) {
1196                                                 /* sreg2 is already assigned to the correct register */
1197                                                 need_spill = FALSE;
1198                                         }
1199                                         else if ((val >= 0) || (val < -1)) {
1200                                                 /* FIXME: sreg2 already assigned to another register */
1201                                                 g_assert_not_reached ();
1202                                         }
1203                                 }
1204
1205                                 if (need_spill) {
1206                                         DEBUG (printf ("\tforced spill of R%d\n", rs->isymbolic [dest_sreg2]));
1207                                         get_register_force_spilling (cfg, tmp, ins, rs->isymbolic [dest_sreg2], FALSE);
1208                                         mono_regstate_free_int (rs, dest_sreg2);
1209                                 }
1210
1211                                 if (!is_global_ireg (ins->sreg2))
1212                                         /* force-set sreg2 */
1213                                         assign_ireg (cfg, rs, ins->sreg2, dest_sreg2);
1214                         }
1215                         ins->sreg2 = dest_sreg2;
1216                 }
1217
1218                 /*
1219                  * TRACK DREG
1220                  */
1221                 fp = dreg_is_fp (spec);
1222                 if (spec [MONO_INST_DEST] && (!fp || (fp && !use_fpstack)) && is_soft_reg (ins->dreg, fp))
1223                         prev_dreg = ins->dreg;
1224
1225                 if (spec [MONO_INST_DEST] == 'b') {
1226                         /*
1227                          * The dest reg is read by the instruction, not written, so
1228                          * avoid allocating sreg1/sreg2 to the same reg.
1229                          */
1230                         if (dest_sreg1 != -1)
1231                                 dreg_mask &= ~ (regmask (dest_sreg1));
1232                         if (dest_sreg2 != -1)
1233                                 dreg_mask &= ~ (regmask (dest_sreg2));
1234
1235                         val = rassign (cfg, ins->dreg, fp);
1236                         if (is_soft_reg (ins->dreg, fp) && (val >= 0) && (!(regmask (val) & dreg_mask))) {
1237                                 /* DREG is already allocated to a register needed for sreg1 */
1238                                 get_register_force_spilling (cfg, tmp, ins, ins->dreg, FALSE);
1239                                 mono_regstate_free_int (rs, val);
1240                         }
1241                 }
1242
1243                 /*
1244                  * If dreg is a fixed regpair, free up both of the needed hregs to avoid
1245                  * various complex situations.
1246                  */
1247                 if (MONO_ARCH_INST_IS_REGPAIR (spec [MONO_INST_DEST])) {
1248                         guint32 dreg2, dest_dreg2;
1249
1250                         g_assert (is_soft_reg (ins->dreg, fp));
1251
1252                         if (dest_dreg != -1) {
1253                                 if (rs->vassign [ins->dreg] != dest_dreg)
1254                                         free_up_ireg (cfg, tmp, ins, dest_dreg);
1255
1256                                 dreg2 = ins->dreg + 1;
1257                                 dest_dreg2 = MONO_ARCH_INST_REGPAIR_REG2 (spec [MONO_INST_DEST], dest_dreg);
1258                                 if (dest_dreg2 != -1) {
1259                                         if (rs->vassign [dreg2] != dest_dreg2)
1260                                                 free_up_ireg (cfg, tmp, ins, dest_dreg2);
1261                                 }
1262                         }
1263                 }
1264
1265                 if (dreg_fixed_mask) {
1266                         g_assert (!fp);
1267                         if (is_global_ireg (ins->dreg)) {
1268                                 /*
1269                                  * The argument is already in a hard reg, but that reg is
1270                                  * not usable by this instruction, so allocate a new one.
1271                                  */
1272                                 val = mono_regstate_alloc_int (rs, dreg_fixed_mask);
1273                                 if (val < 0)
1274                                         val = get_register_spilling (cfg, tmp, ins, dreg_fixed_mask, -1, fp);
1275                                 mono_regstate_free_int (rs, val);
1276                                 dest_dreg = val;
1277
1278                                 /* Fall through */
1279                         }
1280                         else
1281                                 dreg_mask &= dreg_fixed_mask;
1282                 }
1283
1284                 if ((!fp || (fp && !use_fpstack)) && (is_soft_reg (ins->dreg, fp))) {
1285                         if (dest_dreg != -1)
1286                                 dreg_mask = (regmask (dest_dreg));
1287
1288                         val = rassign (cfg, ins->dreg, fp);
1289
1290                         if (val < 0) {
1291                                 int spill = 0;
1292                                 if (val < -1) {
1293                                         /* the register gets spilled after this inst */
1294                                         spill = -val -1;
1295                                 }
1296                                 val = alloc_reg (cfg, tmp, ins, dreg_mask, ins->dreg, &reginfo [ins->dreg], fp);
1297                                 assign_reg (cfg, rs, ins->dreg, val, fp);
1298                                 if (spill)
1299                                         create_spilled_store (cfg, spill, val, prev_dreg, ins, fp);
1300                         }
1301
1302                         DEBUG (printf ("\tassigned dreg %s to dest R%d\n", mono_regname_full (val, fp), ins->dreg));
1303                         ins->dreg = val;
1304                 }
1305
1306                 /* Handle regpairs */
1307                 if (MONO_ARCH_INST_IS_REGPAIR (spec [MONO_INST_DEST])) {
1308                         int reg2 = prev_dreg + 1;
1309
1310                         g_assert (!fp);
1311                         g_assert (prev_dreg > -1);
1312                         g_assert (!is_global_ireg (rs->vassign [prev_dreg]));
1313                         mask = regpair_reg2_mask (spec [MONO_INST_DEST], rs->vassign [prev_dreg]);
1314 #ifdef __i386__
1315                         /* bug #80489 */
1316                         mask &= ~regmask (X86_ECX);
1317 #endif
1318                         val = rs->vassign [reg2];
1319                         if (val < 0) {
1320                                 int spill = 0;
1321                                 if (val < -1) {
1322                                         /* the register gets spilled after this inst */
1323                                         spill = -val -1;
1324                                 }
1325                                 val = mono_regstate_alloc_int (rs, mask);
1326                                 if (val < 0)
1327                                         val = get_register_spilling (cfg, tmp, ins, mask, reg2, fp);
1328                                 if (spill)
1329                                         create_spilled_store (cfg, spill, val, reg2, ins, fp);
1330                         }
1331                         else {
1332                                 if (! (mask & (regmask (val)))) {
1333                                         val = mono_regstate_alloc_int (rs, mask);
1334                                         if (val < 0)
1335                                                 val = get_register_spilling (cfg, tmp, ins, mask, reg2, fp);
1336
1337                                         /* Reallocate hreg to the correct register */
1338                                         create_copy_ins (cfg, rs->vassign [reg2], val, ins, ip, fp);
1339
1340                                         mono_regstate_free_int (rs, rs->vassign [reg2]);
1341                                 }
1342                         }
1343
1344                         DEBUG (printf ("\tassigned dreg-high %s to dest R%d\n", mono_arch_regname (val), reg2));
1345                         assign_reg (cfg, rs, reg2, val, fp);
1346
1347                         dreg_high = val;
1348                         ins->backend.reg3 = val;
1349
1350                         if (reg_is_freeable (val, fp) && reg2 >= 0 && (reginfo [reg2].born_in >= i)) {
1351                                 DEBUG (printf ("\tfreeable %s (R%d)\n", mono_arch_regname (val), reg2));
1352                                 mono_regstate_free_int (rs, val);
1353                         }
1354                 }
1355
1356                 if ((!fp || (fp && !use_fpstack)) && prev_dreg >= 0 && is_soft_reg (prev_dreg, fp) && reginfo [prev_dreg].born_in >= i) {
1357                         /*
1358                          * In theory, we could free up the hreg even if the vreg is alive,
1359                          * but branches inside bblocks force us to assign the same hreg
1360                          * to a vreg every time it is encountered.
1361                          */
1362                         int dreg = rassign (cfg, prev_dreg, fp);
1363                         g_assert (dreg >= 0);
1364                         DEBUG (printf ("\tfreeable %s (R%d) (born in %d)\n", mono_regname_full (dreg, fp), prev_dreg, reginfo [prev_dreg].born_in));
1365                         if (fp)
1366                                 mono_regstate_free_float (rs, dreg);
1367                         else
1368                                 mono_regstate_free_int (rs, dreg);
1369                 }
1370
1371                 if ((dest_dreg != -1) && (ins->dreg != dest_dreg)) {
1372                         /* this instruction only outputs to dest_dreg, need to copy */
1373                         create_copy_ins (cfg, ins->dreg, dest_dreg, ins, ip, fp);
1374                         ins->dreg = dest_dreg;
1375
1376                         if (fp) {
1377                                 if (rs->fsymbolic [dest_dreg] >= MONO_MAX_FREGS)
1378                                         free_up_reg (cfg, tmp, ins, dest_dreg, fp);
1379                         }
1380                         else {
1381                                 if (rs->isymbolic [dest_dreg] >= MONO_MAX_IREGS)
1382                                         free_up_reg (cfg, tmp, ins, dest_dreg, fp);
1383                         }
1384                 }
1385
1386                 if (spec [MONO_INST_DEST] == 'b') {
1387                         /*
1388                          * The dest reg is read by the instruction, not written, so
1389                          * avoid allocating sreg1/sreg2 to the same reg.
1390                          */
1391                         sreg1_mask &= ~ (regmask (ins->dreg));
1392                         sreg2_mask &= ~ (regmask (ins->dreg));
1393                 }
1394
1395                 /*
1396                  * TRACK CLOBBERING
1397                  */
1398                 if ((clob_reg != -1) && (!(rs->ifree_mask & (regmask (clob_reg))))) {
1399                         DEBUG (printf ("\tforced spill of clobbered reg R%d\n", rs->isymbolic [clob_reg]));
1400                         get_register_force_spilling (cfg, tmp, ins, rs->isymbolic [clob_reg], FALSE);
1401                         mono_regstate_free_int (rs, clob_reg);
1402                 }
1403
1404                 if (spec [MONO_INST_CLOB] == 'c') {
1405                         int j, s, dreg, dreg2;
1406                         guint64 clob_mask;
1407
1408                         clob_mask = MONO_ARCH_CALLEE_REGS;
1409
1410                         /*
1411                          * Need to avoid spilling the dreg since the dreg is not really
1412                          * clobbered by the call.
1413                          */
1414                         if ((prev_dreg != -1) && !dreg_is_fp (spec))
1415                                 dreg = rassign (cfg, prev_dreg, dreg_is_fp (spec));
1416                         else
1417                                 dreg = -1;
1418
1419                         if (MONO_ARCH_INST_IS_REGPAIR (spec [MONO_INST_DEST]))
1420                                 dreg2 = rassign (cfg, prev_dreg + 1, dreg_is_fp (spec));
1421                         else
1422                                 dreg2 = -1;
1423
1424                         for (j = 0; j < MONO_MAX_IREGS; ++j) {
1425                                 s = regmask (j);
1426                                 if ((clob_mask & s) && !(rs->ifree_mask & s) && (j != ins->sreg1) && (j != dreg) && (j != dreg2)) {
1427                                         get_register_force_spilling (cfg, tmp, ins, rs->isymbolic [j], FALSE);
1428                                         mono_regstate_free_int (rs, j);
1429                                 }
1430                         }
1431
1432                         if (!use_fpstack) {
1433                                 clob_mask = MONO_ARCH_CALLEE_FREGS;
1434                                 if ((prev_dreg != -1) && dreg_is_fp (spec))
1435                                         dreg = rassign (cfg, prev_dreg, dreg_is_fp (spec));
1436                                 else
1437                                         dreg = -1;
1438
1439                                 for (j = 0; j < MONO_MAX_FREGS; ++j) {
1440                                         s = regmask (j);
1441                                         if ((clob_mask & s) && !(rs->ffree_mask & s) && (j != ins->sreg1) && (j != dreg)) {
1442                                                 get_register_force_spilling (cfg, tmp, ins, rs->fsymbolic [j], TRUE);
1443                                                 mono_regstate_free_float (rs, j);
1444                                         }
1445                                 }
1446                         }
1447                 }
1448
1449                 /*
1450                  * TRACK ARGUMENT REGS
1451                  */
1452                 if (spec [MONO_INST_CLOB] == 'c') {
1453                         MonoCallInst *call = (MonoCallInst*)ins;
1454                         GSList *list;
1455
1456                         /*
1457                          * This needs to be done before assigning sreg1, so sreg1 will
1458                          * not be assigned one of the argument regs.
1459                          */
1460
1461                         /*
1462                          * Assign all registers in call->out_reg_args to the proper
1463                          * argument registers.
1464                          */
1465
1466                         list = call->out_ireg_args;
1467                         if (list) {
1468                                 while (list) {
1469                                         guint32 regpair;
1470                                         int reg, hreg;
1471
1472                                         regpair = (guint32)(gssize)(list->data);
1473                                         hreg = regpair >> 24;
1474                                         reg = regpair & 0xffffff;
1475
1476                                         assign_reg (cfg, rs, reg, hreg, FALSE);
1477
1478                                         sreg1_mask &= ~(regmask (hreg));
1479
1480                                         DEBUG (printf ("\tassigned arg reg %s to R%d\n", mono_arch_regname (hreg), reg));
1481
1482                                         list = g_slist_next (list);
1483                                 }
1484                         }
1485
1486                         list = call->out_freg_args;
1487                         if (list && !use_fpstack) {
1488                                 while (list) {
1489                                         guint32 regpair;
1490                                         int reg, hreg;
1491
1492                                         regpair = (guint32)(gssize)(list->data);
1493                                         hreg = regpair >> 24;
1494                                         reg = regpair & 0xffffff;
1495
1496                                         assign_reg (cfg, rs, reg, hreg, TRUE);
1497
1498                                         DEBUG (printf ("\tassigned arg reg %s to R%d\n", mono_arch_fregname (hreg), reg));
1499
1500                                         list = g_slist_next (list);
1501                                 }
1502                         }
1503                 }
1504
1505                 /*
1506                  * TRACK SREG1
1507                  */
1508                 fp = sreg1_is_fp (spec);
1509                 if ((!fp || (fp && !use_fpstack))) {
1510                         if (MONO_ARCH_INST_IS_REGPAIR (spec [MONO_INST_DEST]) && (spec [MONO_INST_CLOB] == '1')) {
1511                                 g_assert (is_soft_reg (ins->sreg1, fp));
1512
1513                                 /* To simplify things, we allocate the same regpair to sreg1 and dreg */
1514                                 if (dest_sreg1 != -1)
1515                                         g_assert (dest_sreg1 == ins->dreg);
1516                                 val = mono_regstate_alloc_int (rs, regmask (ins->dreg));
1517                                 g_assert (val >= 0);
1518                                 assign_reg (cfg, rs, ins->sreg1, val, fp);
1519
1520                                 DEBUG (printf ("\tassigned sreg1-low %s to R%d\n", mono_regname_full (val, fp), ins->sreg1));
1521
1522                                 g_assert ((regmask (dreg_high)) & regpair_reg2_mask (spec [MONO_INST_SRC1], ins->dreg));
1523                                 val = mono_regstate_alloc_int (rs, regmask (dreg_high));
1524                                 g_assert (val >= 0);
1525                                 assign_reg (cfg, rs, ins->sreg1 + 1, val, fp);
1526
1527                                 DEBUG (printf ("\tassigned sreg1-high %s to R%d\n", mono_regname_full (val, fp), ins->sreg1 + 1));
1528
1529                                 /* Skip rest of this section */
1530                                 dest_sreg1 = -1;
1531                         }
1532
1533                         if (sreg1_fixed_mask) {
1534                                 g_assert (!fp);
1535                                 if (is_global_ireg (ins->sreg1)) {
1536                                         /*
1537                                          * The argument is already in a hard reg, but that reg is
1538                                          * not usable by this instruction, so allocate a new one.
1539                                          */
1540                                         val = mono_regstate_alloc_int (rs, sreg1_fixed_mask);
1541                                         if (val < 0)
1542                                                 val = get_register_spilling (cfg, tmp, ins, sreg1_fixed_mask, -1, fp);
1543                                         mono_regstate_free_int (rs, val);
1544                                         dest_sreg1 = val;
1545
1546                                         /* Fall through to the dest_sreg1 != -1 case */
1547                                 }
1548                                 else
1549                                         sreg1_mask &= sreg1_fixed_mask;
1550                         }
1551
1552                         if (dest_sreg1 != -1) {
1553                                 sreg1_mask = regmask (dest_sreg1);
1554
1555                                 if (!(rs->ifree_mask & (regmask (dest_sreg1)))) {
1556                                         DEBUG (printf ("\tforced spill of R%d\n", rs->isymbolic [dest_sreg1]));
1557                                         get_register_force_spilling (cfg, tmp, ins, rs->isymbolic [dest_sreg1], FALSE);
1558                                         mono_regstate_free_int (rs, dest_sreg1);
1559                                 }
1560                                 if (is_global_ireg (ins->sreg1)) {
1561                                         /* The argument is already in a hard reg, need to copy */
1562                                         MonoInst *copy = create_copy_ins (cfg, dest_sreg1, ins->sreg1, NULL, ip, FALSE);
1563                                         insert_before_ins (ins, tmp, copy);
1564                                         ins->sreg1 = dest_sreg1;
1565                                 }
1566                         }
1567
1568                         if (is_soft_reg (ins->sreg1, fp)) {
1569                                 val = rassign (cfg, ins->sreg1, fp);
1570                                 prev_sreg1 = ins->sreg1;
1571                                 if (val < 0) {
1572                                         int spill = 0;
1573                                         if (val < -1) {
1574                                                 /* the register gets spilled after this inst */
1575                                                 spill = -val -1;
1576                                         }
1577
1578                                         if (((ins->opcode == OP_MOVE) || (ins->opcode == OP_SETREG)) && !spill && !fp && (is_local_ireg (ins->dreg) && (rs->ifree_mask & (regmask (ins->dreg))))) {
1579                                                 /*
1580                                                  * Allocate the same hreg to sreg1 as well so the
1581                                                  * peephole can get rid of the move.
1582                                                  */
1583                                                 sreg1_mask = regmask (ins->dreg);
1584                                         }
1585
1586                                         val = alloc_reg (cfg, tmp, ins, sreg1_mask, ins->sreg1, &reginfo [ins->sreg1], fp);
1587                                         assign_reg (cfg, rs, ins->sreg1, val, fp);
1588                                         DEBUG (printf ("\tassigned sreg1 %s to R%d\n", mono_regname_full (val, fp), ins->sreg1));
1589
1590                                         if (spill) {
1591                                                 MonoInst *store = create_spilled_store (cfg, spill, val, prev_sreg1, NULL, fp);
1592                                                 /*
1593                                                  * Need to insert before the instruction since it can
1594                                                  * overwrite sreg1.
1595                                                  */
1596                                                 insert_before_ins (ins, tmp, store);
1597                                         }
1598                                 }
1599                                 else if ((dest_sreg1 != -1) && (dest_sreg1 != val)) {
1600                                         create_copy_ins (cfg, dest_sreg1, val, ins, ip, fp);
1601                                 }
1602
1603                                 ins->sreg1 = val;
1604                         }
1605                         else {
1606                                 prev_sreg1 = -1;
1607                         }
1608                         sreg2_mask &= ~(regmask (ins->sreg1));
1609                 }
1610
1611                 /* Handle the case when sreg1 is a regpair but dreg is not */
1612                 if (MONO_ARCH_INST_IS_REGPAIR (spec [MONO_INST_SRC1]) && (spec [MONO_INST_CLOB] != '1')) {
1613                         int reg2 = prev_sreg1 + 1;
1614
1615                         g_assert (!fp);
1616                         g_assert (prev_sreg1 > -1);
1617                         g_assert (!is_global_ireg (rs->vassign [prev_sreg1]));
1618                         mask = regpair_reg2_mask (spec [MONO_INST_SRC1], rs->vassign [prev_sreg1]);
1619                         val = rs->vassign [reg2];
1620                         if (val < 0) {
1621                                 int spill = 0;
1622                                 if (val < -1) {
1623                                         /* the register gets spilled after this inst */
1624                                         spill = -val -1;
1625                                 }
1626                                 val = mono_regstate_alloc_int (rs, mask);
1627                                 if (val < 0)
1628                                         val = get_register_spilling (cfg, tmp, ins, mask, reg2, fp);
1629                                 if (spill)
1630                                         g_assert_not_reached ();
1631                         }
1632                         else {
1633                                 if (! (mask & (regmask (val)))) {
1634                                         /* The vreg is already allocated to a wrong hreg */
1635                                         /* FIXME: */
1636                                         g_assert_not_reached ();
1637 #if 0
1638                                         val = mono_regstate_alloc_int (rs, mask);
1639                                         if (val < 0)
1640                                                 val = get_register_spilling (cfg, tmp, ins, mask, reg2, fp);
1641
1642                                         /* Reallocate hreg to the correct register */
1643                                         create_copy_ins (cfg, rs->vassign [reg2], val, ins, ip, fp);
1644
1645                                         mono_regstate_free_int (rs, rs->vassign [reg2]);
1646 #endif
1647                                 }
1648                         }
1649
1650                         sreg1_high = val;
1651                         DEBUG (printf ("\tassigned sreg1 hreg %s to dest R%d\n", mono_arch_regname (val), reg2));
1652                         assign_reg (cfg, rs, reg2, val, fp);
1653                 }
1654
1655                 /* Handle dreg==sreg1 */
1656                 if (((dreg_is_fp (spec) && spec [MONO_INST_SRC1] == 'f' && !use_fpstack) || spec [MONO_INST_CLOB] == '1') && ins->dreg != ins->sreg1) {
1657                         MonoInst *sreg2_copy = NULL;
1658                         MonoInst *copy;
1659                         gboolean fp = (spec [MONO_INST_SRC1] == 'f');
1660
1661                         if (ins->dreg == ins->sreg2) {
1662                                 /*
1663                                  * copying sreg1 to dreg could clobber sreg2, so allocate a new
1664                                  * register for it.
1665                                  */
1666                                 int reg2 = alloc_reg (cfg, tmp, ins, dreg_mask, ins->sreg2, NULL, fp);
1667
1668                                 DEBUG (printf ("\tneed to copy sreg2 %s to reg %s\n", mono_regname_full (ins->sreg2, fp), mono_regname_full (reg2, fp)));
1669                                 sreg2_copy = create_copy_ins (cfg, reg2, ins->sreg2, NULL, ip, fp);
1670                                 prev_sreg2 = ins->sreg2 = reg2;
1671
1672                                 if (fp)
1673                                         mono_regstate_free_float (rs, reg2);
1674                                 else
1675                                         mono_regstate_free_int (rs, reg2);
1676                         }
1677
1678                         if (MONO_ARCH_INST_IS_REGPAIR (spec [MONO_INST_SRC1])) {
1679                                 /* Copying sreg1_high to dreg could also clobber sreg2 */
1680                                 if (rs->vassign [prev_sreg1 + 1] == ins->sreg2)
1681                                         /* FIXME: */
1682                                         g_assert_not_reached ();
1683
1684                                 /*
1685                                  * sreg1 and dest are already allocated to the same regpair by the
1686                                  * SREG1 allocation code.
1687                                  */
1688                                 g_assert (ins->sreg1 == ins->dreg);
1689                                 g_assert (dreg_high == sreg1_high);
1690                         }
1691
1692                         DEBUG (printf ("\tneed to copy sreg1 %s to dreg %s\n", mono_regname_full (ins->sreg1, fp), mono_regname_full (ins->dreg, fp)));
1693                         copy = create_copy_ins (cfg, ins->dreg, ins->sreg1, NULL, ip, fp);
1694                         insert_before_ins (ins, tmp, copy);
1695
1696                         if (sreg2_copy)
1697                                 insert_before_ins (copy, tmp, sreg2_copy);
1698
1699                         /*
1700                          * Need to prevent sreg2 to be allocated to sreg1, since that
1701                          * would screw up the previous copy.
1702                          */
1703                         sreg2_mask &= ~ (regmask (ins->sreg1));
1704                         /* we set sreg1 to dest as well */
1705                         prev_sreg1 = ins->sreg1 = ins->dreg;
1706                         sreg2_mask &= ~ (regmask (ins->dreg));
1707                 }
1708
1709                 /*
1710                  * TRACK SREG2
1711                  */
1712                 fp = sreg2_is_fp (spec);
1713                 if (MONO_ARCH_INST_IS_REGPAIR (spec [MONO_INST_SRC2]))
1714                         g_assert_not_reached ();
1715                 if ((!fp || (fp && !use_fpstack)) && (is_soft_reg (ins->sreg2, fp))) {
1716                         val = rassign (cfg, ins->sreg2, fp);
1717
1718                         if (val < 0) {
1719                                 int spill = 0;
1720                                 if (val < -1) {
1721                                         /* the register gets spilled after this inst */
1722                                         spill = -val -1;
1723                                 }
1724                                 val = alloc_reg (cfg, tmp, ins, sreg2_mask, ins->sreg2, &reginfo [ins->sreg2], fp);
1725                                 assign_reg (cfg, rs, ins->sreg2, val, fp);
1726                                 DEBUG (printf ("\tassigned sreg2 %s to R%d\n", mono_regname_full (val, fp), ins->sreg2));
1727                                 if (spill) {
1728                                         MonoInst *store = create_spilled_store (cfg, spill, val, prev_sreg2, NULL, fp);
1729                                         /*
1730                                          * Need to insert before the instruction since it can
1731                                          * overwrite sreg2.
1732                                          */
1733                                         insert_before_ins (ins, tmp, store);
1734                                 }
1735                         }
1736                         ins->sreg2 = val;
1737                 }
1738                 else {
1739                         prev_sreg2 = -1;
1740                 }
1741
1742                 /*if (reg_is_freeable (ins->sreg1) && prev_sreg1 >= 0 && reginfo [prev_sreg1].born_in >= i) {
1743                         DEBUG (printf ("freeable %s\n", mono_arch_regname (ins->sreg1)));
1744                         mono_regstate_free_int (rs, ins->sreg1);
1745                 }
1746                 if (reg_is_freeable (ins->sreg2) && prev_sreg2 >= 0 && reginfo [prev_sreg2].born_in >= i) {
1747                         DEBUG (printf ("freeable %s\n", mono_arch_regname (ins->sreg2)));
1748                         mono_regstate_free_int (rs, ins->sreg2);
1749                 }*/
1750
1751                 DEBUG (mono_print_ins (i, ins));
1752                 /* this may result from a insert_before call */
1753                 if (!tmp->next)
1754                         bb->code = tmp->data;
1755                 tmp = tmp->next;
1756         }
1757
1758         g_list_free (fspill_list);
1759 }
1760
1761 CompRelation
1762 mono_opcode_to_cond (int opcode)
1763 {
1764         switch (opcode) {
1765         case CEE_BEQ:
1766         case OP_CEQ:
1767         case OP_IBEQ:
1768         case OP_ICEQ:
1769         case OP_LBEQ:
1770         case OP_LCEQ:
1771         case OP_FBEQ:
1772         case OP_FCEQ:
1773         case OP_COND_EXC_EQ:
1774         case OP_COND_EXC_IEQ:
1775                 return CMP_EQ;
1776         case CEE_BNE_UN:
1777         case OP_IBNE_UN:
1778         case OP_LBNE_UN:
1779         case OP_FBNE_UN:
1780         case OP_COND_EXC_NE_UN:
1781         case OP_COND_EXC_INE_UN:
1782                 return CMP_NE;
1783         case CEE_BLE:
1784         case OP_IBLE:
1785         case OP_LBLE:
1786         case OP_FBLE:
1787                 return CMP_LE;
1788         case CEE_BGE:
1789         case OP_IBGE:
1790         case OP_LBGE:
1791         case OP_FBGE:
1792                 return CMP_GE;
1793         case CEE_BLT:
1794         case OP_CLT:
1795         case OP_IBLT:
1796         case OP_ICLT:
1797         case OP_LBLT:
1798         case OP_LCLT:
1799         case OP_FBLT:
1800         case OP_FCLT:
1801         case OP_COND_EXC_LT:
1802         case OP_COND_EXC_ILT:
1803                 return CMP_LT;
1804         case CEE_BGT:
1805         case OP_CGT:
1806         case OP_IBGT:
1807         case OP_ICGT:
1808         case OP_LBGT:
1809         case OP_LCGT:
1810         case OP_FBGT:
1811         case OP_FCGT:
1812         case OP_COND_EXC_GT:
1813         case OP_COND_EXC_IGT:
1814                 return CMP_GT;
1815
1816         case CEE_BLE_UN:
1817         case OP_IBLE_UN:
1818         case OP_LBLE_UN:
1819         case OP_FBLE_UN:
1820         case OP_COND_EXC_LE_UN:
1821         case OP_COND_EXC_ILE_UN:
1822                 return CMP_LE_UN;
1823         case CEE_BGE_UN:
1824         case OP_IBGE_UN:
1825         case OP_LBGE_UN:
1826         case OP_FBGE_UN:
1827                 return CMP_GE_UN;
1828         case CEE_BLT_UN:
1829         case OP_CLT_UN:
1830         case OP_IBLT_UN:
1831         case OP_ICLT_UN:
1832         case OP_LBLT_UN:
1833         case OP_LCLT_UN:
1834         case OP_FBLT_UN:
1835         case OP_FCLT_UN:
1836         case OP_COND_EXC_LT_UN:
1837         case OP_COND_EXC_ILT_UN:
1838                 return CMP_LT_UN;
1839         case CEE_BGT_UN:
1840         case OP_CGT_UN:
1841         case OP_IBGT_UN:
1842         case OP_ICGT_UN:
1843         case OP_LBGT_UN:
1844         case OP_LCGT_UN:
1845         case OP_FCGT_UN:
1846         case OP_FBGT_UN:
1847         case OP_COND_EXC_GT_UN:
1848         case OP_COND_EXC_IGT_UN:
1849                 return CMP_GT_UN;
1850         default:
1851                 printf ("%s\n", mono_inst_name (opcode));
1852                 g_assert_not_reached ();
1853         }
1854 }
1855
1856 CompType
1857 mono_opcode_to_type (int opcode, int cmp_opcode)
1858 {
1859         if ((opcode >= CEE_BEQ) && (opcode <= CEE_BLT_UN))
1860                 return CMP_TYPE_L;
1861         else if ((opcode >= OP_CEQ) && (opcode <= OP_CLT_UN))
1862                 return CMP_TYPE_L;
1863         else if ((opcode >= OP_IBEQ) && (opcode <= OP_IBLT_UN))
1864                 return CMP_TYPE_I;
1865         else if ((opcode >= OP_ICEQ) && (opcode <= OP_ICLT_UN))
1866                 return CMP_TYPE_I;
1867         else if ((opcode >= OP_LBEQ) && (opcode <= OP_LBLT_UN))
1868                 return CMP_TYPE_L;
1869         else if ((opcode >= OP_LCEQ) && (opcode <= OP_LCLT_UN))
1870                 return CMP_TYPE_L;
1871         else if ((opcode >= OP_FBEQ) && (opcode <= OP_FBLT_UN))
1872                 return CMP_TYPE_F;
1873         else if ((opcode >= OP_FCEQ) && (opcode <= OP_FCLT_UN))
1874                 return CMP_TYPE_F;
1875         else if ((opcode >= OP_COND_EXC_IEQ) && (opcode <= OP_COND_EXC_ILT_UN))
1876                 return CMP_TYPE_I;
1877         else if ((opcode >= OP_COND_EXC_EQ) && (opcode <= OP_COND_EXC_LT_UN)) {
1878                 switch (cmp_opcode) {
1879                 case OP_ICOMPARE:
1880                 case OP_ICOMPARE_IMM:
1881                         return CMP_TYPE_I;
1882                 default:
1883                         return CMP_TYPE_L;
1884                 }
1885         } else {
1886                 g_error ("Unknown opcode '%s' in opcode_to_type", mono_inst_name (opcode));
1887                 return 0;
1888         }
1889 }
1890
1891 gboolean
1892 mono_is_regsize_var (MonoType *t)
1893 {
1894         if (t->byref)
1895                 return TRUE;
1896         t = mono_type_get_underlying_type (t);
1897         switch (t->type) {
1898         case MONO_TYPE_BOOLEAN:
1899         case MONO_TYPE_CHAR:
1900         case MONO_TYPE_I1:
1901         case MONO_TYPE_U1:
1902         case MONO_TYPE_I2:
1903         case MONO_TYPE_U2:
1904         case MONO_TYPE_I4:
1905         case MONO_TYPE_U4:
1906         case MONO_TYPE_I:
1907         case MONO_TYPE_U:
1908         case MONO_TYPE_PTR:
1909         case MONO_TYPE_FNPTR:
1910 #if SIZEOF_VOID_P == 8
1911         case MONO_TYPE_I8:
1912         case MONO_TYPE_U8:
1913 #endif
1914                 return TRUE;
1915         case MONO_TYPE_OBJECT:
1916         case MONO_TYPE_STRING:
1917         case MONO_TYPE_CLASS:
1918         case MONO_TYPE_SZARRAY:
1919         case MONO_TYPE_ARRAY:
1920                 return TRUE;
1921         case MONO_TYPE_GENERICINST:
1922                 if (!mono_type_generic_inst_is_valuetype (t))
1923                         return TRUE;
1924                 return FALSE;
1925         case MONO_TYPE_VALUETYPE:
1926                 return FALSE;
1927         }
1928         return FALSE;
1929 }