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 #include <unistd.h>
  10 #include <sys/mman.h>
  11
  12 #include <mono/metadata/appdomain.h>
  13 #include <mono/metadata/debug-helpers.h>
  14 #include <mono/metadata/threads.h>
  15 #include <mono/metadata/profiler-private.h>
  16 #include <mono/utils/mono-math.h>
  17
  18 #include "mini.h"
  19 #include "trace.h"
  20 #include "inssel.h"
  21 #include "mini-arch.h"
  22
  23 #define DEBUG(a) if (cfg->verbose_level > 1) a
  24
  25 #if defined(__x86_64__)
  26 const char * const amd64_desc [OP_LAST];
  27 static const char*const * ins_spec = amd64_desc;
  28 #elif defined(__sparc__) || defined(sparc)
  29 const char * const sparc_desc [OP_LAST];
  30 static const char*const * ins_spec = sparc_desc;
  31 #elif defined(__i386__)
  32 const char * const pentium_desc [OP_LAST];
  33 static const char*const * ins_spec = pentium_desc;
  34 #elif defined(__ia64__)
  35 const char * const ia64_desc [OP_LAST];
  36 static const char*const * ins_spec = ia64_desc;
  37 #else
  38 #error "Not implemented"
  39 #endif
  40
  41 #define use_fpstack MONO_ARCH_USE_FPSTACK
  42
  43 const char*
  44 mono_regname_full (int reg, gboolean fp)
  45 {
  46         if (fp)
  47                 return mono_arch_fregname (reg);
  48         else
  49                 return mono_arch_regname (reg);
  50 }
  51
  52 void
  53 mono_call_inst_add_outarg_reg (MonoCallInst *call, int vreg, int hreg, gboolean fp)
  54 {
  55         guint32 regpair;
  56
  57         regpair = (((guint32)hreg) << 24) + vreg;
  58         if (fp)
  59                 call->out_freg_args = g_slist_append (call->out_freg_args, (gpointer)(gssize)(regpair));
  60         else
  61                 call->out_ireg_args = g_slist_append (call->out_ireg_args, (gpointer)(gssize)(regpair));
  62 }
  63
  64 /*
  65  * returns the offset used by spillvar. It allocates a new
  66  * spill variable if necessary.
  67  */
  68 static int
  69 mono_spillvar_offset (MonoCompile *cfg, int spillvar)
  70 {
  71         MonoSpillInfo **si, *info;
  72         int i = 0;
  73
  74         si = &cfg->spill_info;
  75
  76         while (i <= spillvar) {
  77
  78                 if (!*si) {
  79                         *si = info = mono_mempool_alloc (cfg->mempool, sizeof (MonoSpillInfo));
  80                         info->next = NULL;
  81                         cfg->stack_offset += sizeof (gpointer);
  82                         info->offset = - cfg->stack_offset;
  83                 }
  84
  85                 if (i == spillvar)
  86                         return (*si)->offset;
  87
  88                 i++;
  89                 si = &(*si)->next;
  90         }
  91
  92         g_assert_not_reached ();
  93         return 0;
  94 }
  95
  96 /*
  97  * returns the offset used by spillvar. It allocates a new
  98  * spill float variable if necessary.
  99  * (same as mono_spillvar_offset but for float)
 100  */
 101 static int
 102 mono_spillvar_offset_float (MonoCompile *cfg, int spillvar)
 103 {
 104         MonoSpillInfo **si, *info;
 105         int i = 0;
 106
 107         si = &cfg->spill_info_float;
 108
 109         while (i <= spillvar) {
 110
 111                 if (!*si) {
 112                         *si = info = mono_mempool_alloc (cfg->mempool, sizeof (MonoSpillInfo));
 113                         info->next = NULL;
 114                         cfg->stack_offset += sizeof (double);
 115                         info->offset = - cfg->stack_offset;
 116                 }
 117
 118                 if (i == spillvar)
 119                         return (*si)->offset;
 120
 121                 i++;
 122                 si = &(*si)->next;
 123         }
 124
 125         g_assert_not_reached ();
 126         return 0;
 127 }
 128
 129 /*
 130  * Creates a store for spilled floating point items
 131  */
 132 static MonoInst*
 133 create_spilled_store_float (MonoCompile *cfg, int spill, int reg, MonoInst *ins)
 134 {
 135         MonoInst *store;
 136         MONO_INST_NEW (cfg, store, OP_STORER8_MEMBASE_REG);
 137         store->sreg1 = reg;
 138         store->inst_destbasereg = cfg->frame_reg;
 139         store->inst_offset = mono_spillvar_offset_float (cfg, spill);
 140
 141         DEBUG (g_print ("SPILLED FLOAT STORE (%d at 0x%08lx(%%sp)) (from %d)\n", spill, (long)store->inst_offset, reg));
 142         return store;
 143 }
 144
 145 /*
 146  * Creates a load for spilled floating point items
 147  */
 148 static MonoInst*
 149 create_spilled_load_float (MonoCompile *cfg, int spill, int reg, MonoInst *ins)
 150 {
 151         MonoInst *load;
 152         MONO_INST_NEW (cfg, load, OP_LOADR8_SPILL_MEMBASE);
 153         load->dreg = reg;
 154         load->inst_basereg = cfg->frame_reg;
 155         load->inst_offset = mono_spillvar_offset_float (cfg, spill);
 156
 157         DEBUG (g_print ("SPILLED FLOAT LOAD (%d at 0x%08lx(%%sp)) (from %d)\n", spill, (long)load->inst_offset, reg));
 158         return load;
 159 }
 160
 161 #define is_hard_ireg(r) ((r) >= 0 && (r) < MONO_MAX_IREGS)
 162 #define is_hard_freg(r) ((r) >= 0 && (r) < MONO_MAX_FREGS)
 163 #define is_global_ireg(r) (is_hard_ireg ((r)) && (MONO_ARCH_CALLEE_SAVED_REGS & (1 << (r))))
 164 #define is_local_ireg(r) (is_hard_ireg ((r)) && (MONO_ARCH_CALLEE_REGS & (1 << (r))))
 165 #define is_global_freg(r) (is_hard_freg ((r)) && (MONO_ARCH_CALLEE_SAVED_FREGS & (1 << (r))))
 166 #define is_local_freg(r) (is_hard_ireg ((r)) && (MONO_ARCH_CALLEE_FREGS & (1 << (r))))
 167 #define ireg_is_freeable(r) is_local_ireg ((r))
 168 #define freg_is_freeable(r) is_hard_freg ((r))
 169
 170 #define reg_is_freeable(r,fp) ((fp) ? freg_is_freeable ((r)) : ireg_is_freeable ((r)))
 171 #define is_hard_reg(r,fp) ((fp) ? ((r) < MONO_MAX_FREGS) : ((r) < MONO_MAX_IREGS))
 172 #define is_soft_reg(r,fp) (!is_hard_reg((r),(fp)))
 173 #define rassign(cfg,reg,fp) ((fp) ? (cfg)->rs->fassign [(reg)] : (cfg)->rs->iassign [(reg)])
 174 #define sreg1_is_fp(ins) (ins_spec [(ins)->opcode] [MONO_INST_SRC1] == 'f')
 175 #define sreg2_is_fp(ins) (ins_spec [(ins)->opcode] [MONO_INST_SRC2] == 'f')
 176
 177 #ifdef MONO_ARCH_INST_IS_FLOAT
 178 #define dreg_is_fp(ins)  (MONO_ARCH_INST_IS_FLOAT (ins_spec [(ins)->opcode] [MONO_INST_DEST]))
 179 #else
 180 #define dreg_is_fp(ins)  (ins_spec [(ins)->opcode] [MONO_INST_DEST] == 'f')
 181 #endif
 182
 183 #define regpair_reg2_mask(desc,hreg1) ((MONO_ARCH_INST_REGPAIR_REG2 (desc,hreg1) != -1) ? (1 << MONO_ARCH_INST_REGPAIR_REG2 (desc,hreg1)) : MONO_ARCH_CALLEE_REGS)
 184
 185 typedef struct {
 186         int born_in;
 187         int killed_in;
 188         int last_use;
 189         int prev_use;
 190         int flags;              /* used to track fp spill/load */
 191         guint32 preferred_mask; /* the hreg where the register should be allocated, or 0 */
 192 } RegTrack;
 193
 194 static void
 195 print_ins (int i, MonoInst *ins)
 196 {
 197         const char *spec = ins_spec [ins->opcode];
 198         g_print ("\t%-2d %s", i, mono_inst_name (ins->opcode));
 199         if (!spec)
 200                 g_error ("Unknown opcode: %s\n", mono_inst_name (ins->opcode));
 201
 202         if (spec [MONO_INST_DEST]) {
 203                 gboolean fp = dreg_is_fp (ins);
 204                 if (is_soft_reg (ins->dreg, fp))
 205                         g_print (" R%d <-", ins->dreg);
 206                 else if (spec [MONO_INST_DEST] == 'b') {
 207                         if (ins->inst_offset == 0)
 208                                 g_print (" [%s] <-", mono_arch_regname (ins->dreg));
 209                         else
 210                                 g_print (" [%s + 0x%lx] <-", mono_arch_regname (ins->dreg), (long)ins->inst_offset);
 211                 } else
 212                         g_print (" %s <-", mono_regname_full (ins->dreg, fp));
 213         }
 214         if (spec [MONO_INST_SRC1]) {
 215                 gboolean fp = (spec [MONO_INST_SRC1] == 'f');
 216                 if (is_soft_reg (ins->sreg1, fp))
 217                         g_print (" R%d", ins->sreg1);
 218                 else if (spec [MONO_INST_SRC1] == 'b')
 219                         g_print (" [%s + 0x%lx]", mono_arch_regname (ins->sreg1), (long)ins->inst_offset);
 220                 else
 221                         g_print (" %s", mono_regname_full (ins->sreg1, fp));
 222         }
 223         if (spec [MONO_INST_SRC2]) {
 224                 gboolean fp = (spec [MONO_INST_SRC2] == 'f');
 225                 if (is_soft_reg (ins->sreg2, fp))
 226                         g_print (" R%d", ins->sreg2);
 227                 else
 228                         g_print (" %s", mono_regname_full (ins->sreg2, fp));
 229         }
 230         if (spec [MONO_INST_CLOB])
 231                 g_print (" clobbers: %c", spec [MONO_INST_CLOB]);
 232         g_print ("\n");
 233 }
 234
 235 static void
 236 print_regtrack (RegTrack *t, int num)
 237 {
 238         int i;
 239         char buf [32];
 240         const char *r;
 241
 242         for (i = 0; i < num; ++i) {
 243                 if (!t [i].born_in)
 244                         continue;
 245                 if (i >= MONO_MAX_IREGS) {
 246                         g_snprintf (buf, sizeof(buf), "R%d", i);
 247                         r = buf;
 248                 } else
 249                         r = mono_arch_regname (i);
 250                 g_print ("liveness: %s [%d - %d]\n", r, t [i].born_in, t[i].last_use);
 251         }
 252 }
 253
 254 typedef struct InstList InstList;
 255
 256 struct InstList {
 257         InstList *prev;
 258         InstList *next;
 259         MonoInst *data;
 260 };
 261
 262 static inline InstList*
 263 inst_list_prepend (MonoMemPool *pool, InstList *list, MonoInst *data)
 264 {
 265         InstList *item = mono_mempool_alloc (pool, sizeof (InstList));
 266         item->data = data;
 267         item->prev = NULL;
 268         item->next = list;
 269         if (list)
 270                 list->prev = item;
 271         return item;
 272 }
 273
 274 /*
 275  * Force the spilling of the variable in the symbolic register 'reg'.
 276  */
 277 static int
 278 get_register_force_spilling (MonoCompile *cfg, InstList *item, MonoInst *ins, int reg, gboolean fp)
 279 {
 280         MonoInst *load;
 281         int i, sel, spill;
 282         int *assign, *symbolic;
 283
 284         if (fp) {
 285                 assign = cfg->rs->fassign;
 286                 symbolic = cfg->rs->fsymbolic;
 287         }
 288         else {
 289                 assign = cfg->rs->iassign;
 290                 symbolic = cfg->rs->isymbolic;
 291         }
 292
 293         sel = assign [reg];
 294         /*i = cfg->rs->isymbolic [sel];
 295         g_assert (i == reg);*/
 296         i = reg;
 297         spill = ++cfg->spill_count;
 298         assign [i] = -spill - 1;
 299         if (fp)
 300                 mono_regstate_free_float (cfg->rs, sel);
 301         else
 302                 mono_regstate_free_int (cfg->rs, sel);
 303         /* we need to create a spill var and insert a load to sel after the current instruction */
 304         if (fp)
 305                 MONO_INST_NEW (cfg, load, OP_LOADR8_MEMBASE);
 306         else
 307                 MONO_INST_NEW (cfg, load, OP_LOAD_MEMBASE);
 308         load->dreg = sel;
 309         load->inst_basereg = cfg->frame_reg;
 310         load->inst_offset = mono_spillvar_offset (cfg, spill);
 311         if (item->prev) {
 312                 while (ins->next != item->prev->data)
 313                         ins = ins->next;
 314         }
 315         load->next = ins->next;
 316         ins->next = load;
 317         DEBUG (g_print ("SPILLED LOAD (%d at 0x%08lx(%%ebp)) R%d (freed %s)\n", spill, (long)load->inst_offset, i, mono_regname_full (sel, fp)));
 318         if (fp)
 319                 i = mono_regstate_alloc_float (cfg->rs, 1 << sel);
 320         else
 321                 i = mono_regstate_alloc_int (cfg->rs, 1 << sel);
 322         g_assert (i == sel);
 323
 324         return sel;
 325 }
 326
 327 static int
 328 get_register_spilling (MonoCompile *cfg, InstList *item, MonoInst *ins, guint32 regmask, int reg, gboolean fp)
 329 {
 330         MonoInst *load;
 331         int i, sel, spill;
 332         int *assign, *symbolic;
 333
 334         if (fp) {
 335                 assign = cfg->rs->fassign;
 336                 symbolic = cfg->rs->fsymbolic;
 337         }
 338         else {
 339                 assign = cfg->rs->iassign;
 340                 symbolic = cfg->rs->isymbolic;
 341         }
 342
 343         DEBUG (g_print ("\tstart regmask to assign R%d: 0x%08x (R%d <- R%d R%d)\n", reg, regmask, ins->dreg, ins->sreg1, ins->sreg2));
 344         /* exclude the registers in the current instruction */
 345         if ((sreg1_is_fp (ins) == fp) && (reg != ins->sreg1) && (reg_is_freeable (ins->sreg1, fp) || (is_soft_reg (ins->sreg1, fp) && rassign (cfg, ins->sreg1, fp) >= 0))) {
 346                 if (is_soft_reg (ins->sreg1, fp))
 347                         regmask &= ~ (1 << rassign (cfg, ins->sreg1, fp));
 348                 else
 349                         regmask &= ~ (1 << ins->sreg1);
 350                 DEBUG (g_print ("\t\texcluding sreg1 %s\n", mono_regname_full (ins->sreg1, fp)));
 351         }
 352         if ((sreg2_is_fp (ins) == fp) && (reg != ins->sreg2) && (reg_is_freeable (ins->sreg2, fp) || (is_soft_reg (ins->sreg2, fp) && rassign (cfg, ins->sreg2, fp) >= 0))) {
 353                 if (is_soft_reg (ins->sreg2, fp))
 354                         regmask &= ~ (1 << rassign (cfg, ins->sreg2, fp));
 355                 else
 356                         regmask &= ~ (1 << ins->sreg2);
 357                 DEBUG (g_print ("\t\texcluding sreg2 %s %d\n", mono_regname_full (ins->sreg2, fp), ins->sreg2));
 358         }
 359         if ((dreg_is_fp (ins) == fp) && (reg != ins->dreg) && reg_is_freeable (ins->dreg, fp)) {
 360                 regmask &= ~ (1 << ins->dreg);
 361                 DEBUG (g_print ("\t\texcluding dreg %s\n", mono_regname_full (ins->dreg, fp)));
 362         }
 363
 364         DEBUG (g_print ("\t\tavailable regmask: 0x%08x\n", regmask));
 365         g_assert (regmask); /* need at least a register we can free */
 366         sel = -1;
 367         /* we should track prev_use and spill the register that's farther */
 368         if (fp) {
 369                 for (i = 0; i < MONO_MAX_FREGS; ++i) {
 370                         if (regmask & (1 << i)) {
 371                                 sel = i;
 372                                 DEBUG (g_print ("\t\tselected register %s has assignment %d\n", mono_arch_fregname (sel), cfg->rs->fsymbolic [sel]));
 373                                 break;
 374                         }
 375                 }
 376
 377                 i = cfg->rs->fsymbolic [sel];
 378                 spill = ++cfg->spill_count;
 379                 cfg->rs->fassign [i] = -spill - 1;
 380                 mono_regstate_free_float (cfg->rs, sel);
 381         }
 382         else {
 383                 for (i = 0; i < MONO_MAX_IREGS; ++i) {
 384                         if (regmask & (1 << i)) {
 385                                 sel = i;
 386                                 DEBUG (g_print ("\t\tselected register %s has assignment %d\n", mono_arch_regname (sel), cfg->rs->isymbolic [sel]));
 387                                 break;
 388                         }
 389                 }
 390
 391                 i = cfg->rs->isymbolic [sel];
 392                 spill = ++cfg->spill_count;
 393                 cfg->rs->iassign [i] = -spill - 1;
 394                 mono_regstate_free_int (cfg->rs, sel);
 395         }
 396
 397         /* we need to create a spill var and insert a load to sel after the current instruction */
 398         MONO_INST_NEW (cfg, load, fp ? OP_LOADR8_MEMBASE : OP_LOAD_MEMBASE);
 399         load->dreg = sel;
 400         load->inst_basereg = cfg->frame_reg;
 401         load->inst_offset = mono_spillvar_offset (cfg, spill);
 402         if (item->prev) {
 403                 while (ins->next != item->prev->data)
 404                         ins = ins->next;
 405         }
 406         load->next = ins->next;
 407         ins->next = load;
 408         DEBUG (g_print ("\tSPILLED LOAD (%d at 0x%08lx(%%ebp)) R%d (freed %s)\n", spill, (long)load->inst_offset, i, mono_regname_full (sel, fp)));
 409         if (fp)
 410                 i = mono_regstate_alloc_float (cfg->rs, 1 << sel);
 411         else
 412                 i = mono_regstate_alloc_int (cfg->rs, 1 << sel);
 413         g_assert (i == sel);
 414
 415         return sel;
 416 }
 417
 418 static void
 419 free_up_ireg (MonoCompile *cfg, InstList *item, MonoInst *ins, int hreg)
 420 {
 421         if (!(cfg->rs->ifree_mask & (1 << hreg))) {
 422                 DEBUG (g_print ("\tforced spill of R%d\n", cfg->rs->isymbolic [hreg]));
 423                 get_register_force_spilling (cfg, item, ins, cfg->rs->isymbolic [hreg], FALSE);
 424                 mono_regstate_free_int (cfg->rs, hreg);
 425         }
 426 }
 427
 428 static void
 429 free_up_reg (MonoCompile *cfg, InstList *item, MonoInst *ins, int hreg, gboolean fp)
 430 {
 431         if (fp) {
 432                 if (!(cfg->rs->ffree_mask & (1 << hreg))) {
 433                         DEBUG (g_print ("\tforced spill of R%d\n", cfg->rs->isymbolic [hreg]));
 434                         get_register_force_spilling (cfg, item, ins, cfg->rs->isymbolic [hreg], fp);
 435                         mono_regstate_free_float (cfg->rs, hreg);
 436                 }
 437         }
 438         else {
 439                 if (!(cfg->rs->ifree_mask & (1 << hreg))) {
 440                         DEBUG (g_print ("\tforced spill of R%d\n", cfg->rs->isymbolic [hreg]));
 441                         get_register_force_spilling (cfg, item, ins, cfg->rs->isymbolic [hreg], fp);
 442                         mono_regstate_free_int (cfg->rs, hreg);
 443                 }
 444         }
 445 }
 446
 447 static MonoInst*
 448 create_copy_ins (MonoCompile *cfg, int dest, int src, MonoInst *ins, gboolean fp)
 449 {
 450         MonoInst *copy;
 451
 452         if (fp)
 453                 MONO_INST_NEW (cfg, copy, OP_FMOVE);
 454         else
 455                 MONO_INST_NEW (cfg, copy, OP_MOVE);
 456
 457         copy->dreg = dest;
 458         copy->sreg1 = src;
 459         if (ins) {
 460                 copy->next = ins->next;
 461                 ins->next = copy;
 462         }
 463         DEBUG (g_print ("\tforced copy from %s to %s\n", mono_regname_full (src, fp), mono_regname_full (dest, fp)));
 464         return copy;
 465 }
 466
 467 static MonoInst*
 468 create_spilled_store (MonoCompile *cfg, int spill, int reg, int prev_reg, MonoInst *ins, gboolean fp)
 469 {
 470         MonoInst *store;
 471         MONO_INST_NEW (cfg, store, fp ? OP_STORER8_MEMBASE_REG : OP_STORE_MEMBASE_REG);
 472         store->sreg1 = reg;
 473         store->inst_destbasereg = cfg->frame_reg;
 474         store->inst_offset = mono_spillvar_offset (cfg, spill);
 475         if (ins) {
 476                 store->next = ins->next;
 477                 ins->next = store;
 478         }
 479         DEBUG (g_print ("\tSPILLED STORE (%d at 0x%08lx(%%ebp)) R%d (from %s)\n", spill, (long)store->inst_offset, prev_reg, mono_regname_full (reg, fp)));
 480         return store;
 481 }
 482
 483 static void
 484 insert_before_ins (MonoInst *ins, InstList *item, MonoInst* to_insert)
 485 {
 486         MonoInst *prev;
 487         if (item->next) {
 488                 prev = item->next->data;
 489
 490                 while (prev->next != ins)
 491                         prev = prev->next;
 492                 to_insert->next = ins;
 493                 prev->next = to_insert;
 494         } else {
 495                 to_insert->next = ins;
 496         }
 497         /*
 498          * needed otherwise in the next instruction we can add an ins to the
 499          * end and that would get past this instruction.
 500          */
 501         item->data = to_insert;
 502 }
 503
 504 /* flags used in reginfo->flags */
 505 enum {
 506         MONO_FP_NEEDS_LOAD_SPILL        = 1 << 0,
 507         MONO_FP_NEEDS_SPILL                     = 1 << 1,
 508         MONO_FP_NEEDS_LOAD                      = 1 << 2
 509 };
 510
 511 static int
 512 alloc_int_reg (MonoCompile *cfg, InstList *tmp, MonoInst *ins, guint32 dest_mask, int sym_reg, RegTrack *info)
 513 {
 514         int val;
 515
 516         if (info && info->preferred_mask) {
 517                 val = mono_regstate_alloc_int (cfg->rs, info->preferred_mask & dest_mask);
 518                 if (val >= 0) {
 519                         DEBUG (g_print ("\tallocated preferred reg R%d to %s\n", sym_reg, mono_arch_regname (val)));
 520                         return val;
 521                 }
 522         }
 523
 524         val = mono_regstate_alloc_int (cfg->rs, dest_mask);
 525         if (val < 0)
 526                 val = get_register_spilling (cfg, tmp, ins, dest_mask, sym_reg, FALSE);
 527
 528         return val;
 529 }
 530
 531 static int
 532 alloc_float_reg (MonoCompile *cfg, InstList *tmp, MonoInst *ins, guint32 dest_mask, int sym_reg)
 533 {
 534         int val;
 535
 536         val = mono_regstate_alloc_float (cfg->rs, dest_mask);
 537
 538         if (val < 0) {
 539                 val = get_register_spilling (cfg, tmp, ins, dest_mask, sym_reg, TRUE);
 540         }
 541
 542         return val;
 543 }
 544
 545 static int
 546 alloc_reg (MonoCompile *cfg, InstList *tmp, MonoInst *ins, guint32 dest_mask, int sym_reg, RegTrack *info, gboolean fp)
 547 {
 548         if (fp)
 549                 return alloc_float_reg (cfg, tmp, ins, dest_mask, sym_reg);
 550         else
 551                 return alloc_int_reg (cfg, tmp, ins, dest_mask, sym_reg, info);
 552 }
 553
 554 static inline void
 555 assign_reg (MonoRegState *rs, int reg, int hreg, gboolean fp)
 556 {
 557         if (fp) {
 558                 g_assert (reg >= MONO_MAX_FREGS);
 559                 g_assert (hreg < MONO_MAX_FREGS);
 560                 g_assert (! is_global_freg (hreg));
 561
 562                 rs->fassign [reg] = hreg;
 563                 rs->fsymbolic [hreg] = reg;
 564                 rs->ffree_mask &= ~ (1 << hreg);
 565         }
 566         else {
 567                 g_assert (reg >= MONO_MAX_IREGS);
 568                 g_assert (hreg < MONO_MAX_IREGS);
 569                 g_assert (! is_global_ireg (hreg));
 570
 571                 rs->iassign [reg] = hreg;
 572                 rs->isymbolic [hreg] = reg;
 573                 rs->ifree_mask &= ~ (1 << hreg);
 574         }
 575 }
 576
 577 static inline void
 578 assign_ireg (MonoRegState *rs, int reg, int hreg)
 579 {
 580         assign_reg (rs, reg, hreg, FALSE);
 581 }
 582
 583 /*
 584  * Local register allocation.
 585  * We first scan the list of instructions and we save the liveness info of
 586  * each register (when the register is first used, when it's value is set etc.).
 587  * We also reverse the list of instructions (in the InstList list) because assigning
 588  * registers backwards allows for more tricks to be used.
 589  */
 590 void
 591 mono_local_regalloc (MonoCompile *cfg, MonoBasicBlock *bb)
 592 {
 593         MonoInst *ins;
 594         MonoRegState *rs = cfg->rs;
 595         int i, val, fpcount;
 596         RegTrack *reginfo, *reginfof;
 597         RegTrack *reginfo1, *reginfo2, *reginfod;
 598         InstList *tmp, *reversed = NULL;
 599         const char *spec;
 600         GList *fspill_list = NULL;
 601         gboolean fp;
 602         int fspill = 0;
 603
 604         if (!bb->code)
 605                 return;
 606
 607         rs->next_vireg = bb->max_ireg;
 608         rs->next_vfreg = bb->max_freg;
 609         mono_regstate_assign (rs);
 610         reginfo = g_malloc0 (sizeof (RegTrack) * rs->next_vireg);
 611         reginfof = g_malloc0 (sizeof (RegTrack) * rs->next_vfreg);
 612         rs->ifree_mask = MONO_ARCH_CALLEE_REGS;
 613         rs->ffree_mask = MONO_ARCH_CALLEE_FREGS;
 614
 615         if (use_fpstack)
 616                 rs->ffree_mask = 0xff & ~(1 << MONO_ARCH_FPSTACK_SIZE);
 617
 618         ins = bb->code;
 619
 620         /*if (cfg->opt & MONO_OPT_COPYPROP)
 621                 local_copy_prop (cfg, ins);*/
 622
 623         i = 1;
 624         fpcount = 0;
 625         DEBUG (g_print ("LOCAL regalloc: basic block: %d\n", bb->block_num));
 626         /* forward pass on the instructions to collect register liveness info */
 627         while (ins) {
 628                 spec = ins_spec [ins->opcode];
 629
 630                 if (!spec) {
 631                         g_error ("Opcode '%s' missing from machine description file.", mono_inst_name (ins->opcode));
 632                 }
 633
 634                 DEBUG (print_ins (i, ins));
 635
 636                 /*
 637                  * TRACK FP STACK
 638                  */
 639                 if (use_fpstack) {
 640                         GList *spill;
 641
 642                         if (spec [MONO_INST_SRC1] == 'f') {
 643                                 spill = g_list_first (fspill_list);
 644                                 if (spill && fpcount < MONO_ARCH_FPSTACK_SIZE) {
 645                                         reginfof [ins->sreg1].flags |= MONO_FP_NEEDS_LOAD;
 646                                         fspill_list = g_list_remove (fspill_list, spill->data);
 647                                 } else
 648                                         fpcount--;
 649                         }
 650
 651                         if (spec [MONO_INST_SRC2] == 'f') {
 652                                 spill = g_list_first (fspill_list);
 653                                 if (spill) {
 654                                         reginfof [ins->sreg2].flags |= MONO_FP_NEEDS_LOAD;
 655                                         fspill_list = g_list_remove (fspill_list, spill->data);
 656                                         if (fpcount >= MONO_ARCH_FPSTACK_SIZE) {
 657                                                 fspill++;
 658                                                 fspill_list = g_list_prepend (fspill_list, GINT_TO_POINTER(fspill));
 659                                                 reginfof [ins->sreg2].flags |= MONO_FP_NEEDS_LOAD_SPILL;
 660                                         }
 661                                 } else
 662                                         fpcount--;
 663                         }
 664
 665                         if (dreg_is_fp (ins)) {
 666                                 if (use_fpstack && (spec [MONO_INST_CLOB] != 'm')) {
 667                                         if (fpcount >= MONO_ARCH_FPSTACK_SIZE) {
 668                                                 reginfof [ins->dreg].flags |= MONO_FP_NEEDS_SPILL;
 669                                                 fspill++;
 670                                                 fspill_list = g_list_prepend (fspill_list, GINT_TO_POINTER(fspill));
 671                                                 fpcount--;
 672                                         }
 673                                         fpcount++;
 674                                 }
 675                         }
 676                 }
 677
 678                 if (spec [MONO_INST_SRC1]) {
 679                         if (spec [MONO_INST_SRC1] == 'f')
 680                                 reginfo1 = reginfof;
 681                         else
 682                                 reginfo1 = reginfo;
 683                         reginfo1 [ins->sreg1].prev_use = reginfo1 [ins->sreg1].last_use;
 684                         reginfo1 [ins->sreg1].last_use = i;
 685                         if (MONO_ARCH_INST_IS_REGPAIR (spec [MONO_INST_SRC2])) {
 686                                 /* The virtual register is allocated sequentially */
 687                                 reginfo1 [ins->sreg1 + 1].prev_use = reginfo1 [ins->sreg1 + 1].last_use;
 688                                 reginfo1 [ins->sreg1 + 1].last_use = i;
 689                                 if (reginfo1 [ins->sreg1 + 1].born_in == 0 || reginfo1 [ins->sreg1 + 1].born_in > i)
 690                                         reginfo1 [ins->sreg1 + 1].born_in = i;
 691                         }
 692                 } else {
 693                         ins->sreg1 = -1;
 694                 }
 695                 if (spec [MONO_INST_SRC2]) {
 696                         if (spec [MONO_INST_SRC2] == 'f')
 697                                 reginfo2 = reginfof;
 698                         else
 699                                 reginfo2 = reginfo;
 700                         reginfo2 [ins->sreg2].prev_use = reginfo2 [ins->sreg2].last_use;
 701                         reginfo2 [ins->sreg2].last_use = i;
 702                         if (MONO_ARCH_INST_IS_REGPAIR (spec [MONO_INST_SRC2])) {
 703                                 /* The virtual register is allocated sequentially */
 704                                 reginfo2 [ins->sreg2 + 1].prev_use = reginfo2 [ins->sreg2 + 1].last_use;
 705                                 reginfo2 [ins->sreg2 + 1].last_use = i;
 706                                 if (reginfo2 [ins->sreg2 + 1].born_in == 0 || reginfo2 [ins->sreg2 + 1].born_in > i)
 707                                         reginfo2 [ins->sreg2 + 1].born_in = i;
 708                         }
 709                 } else {
 710                         ins->sreg2 = -1;
 711                 }
 712                 if (spec [MONO_INST_DEST]) {
 713                         int dest_dreg;
 714
 715                         if (dreg_is_fp (ins))
 716                                 reginfod = reginfof;
 717                         else
 718                                 reginfod = reginfo;
 719                         if (spec [MONO_INST_DEST] != 'b') /* it's not just a base register */
 720                                 reginfod [ins->dreg].killed_in = i;
 721                         reginfod [ins->dreg].prev_use = reginfod [ins->dreg].last_use;
 722                         reginfod [ins->dreg].last_use = i;
 723                         if (reginfod [ins->dreg].born_in == 0 || reginfod [ins->dreg].born_in > i)
 724                                 reginfod [ins->dreg].born_in = i;
 725
 726                         dest_dreg = MONO_ARCH_INST_FIXED_REG (spec [MONO_INST_DEST]);
 727                         if (dest_dreg != -1)
 728                                 reginfod [ins->dreg].preferred_mask = (1 << dest_dreg);
 729
 730                         if (MONO_ARCH_INST_IS_REGPAIR (spec [MONO_INST_DEST])) {
 731                                 /* The virtual register is allocated sequentially */
 732                                 reginfod [ins->dreg + 1].prev_use = reginfod [ins->dreg + 1].last_use;
 733                                 reginfod [ins->dreg + 1].last_use = i;
 734                                 if (reginfod [ins->dreg + 1].born_in == 0 || reginfod [ins->dreg + 1].born_in > i)
 735                                         reginfod [ins->dreg + 1].born_in = i;
 736                                 if (MONO_ARCH_INST_REGPAIR_REG2 (spec [MONO_INST_DEST], -1) != -1)
 737                                         reginfod [ins->dreg + 1].preferred_mask = regpair_reg2_mask (spec [MONO_INST_DEST], -1);
 738                         }
 739                 } else {
 740                         ins->dreg = -1;
 741                 }
 742
 743                 if (spec [MONO_INST_CLOB] == 'c') {
 744                         /* A call instruction implicitly uses all registers in call->out_ireg_args */
 745
 746                         MonoCallInst *call = (MonoCallInst*)ins;
 747                         GSList *list;
 748
 749                         list = call->out_ireg_args;
 750                         if (list) {
 751                                 while (list) {
 752                                         guint32 regpair;
 753                                         int reg, hreg;
 754
 755                                         regpair = (guint32)(gssize)(list->data);
 756                                         hreg = regpair >> 24;
 757                                         reg = regpair & 0xffffff;
 758
 759                                         reginfo [reg].prev_use = reginfo [reg].last_use;
 760                                         reginfo [reg].last_use = i;
 761
 762                                         list = g_slist_next (list);
 763                                 }
 764                         }
 765
 766                         list = call->out_freg_args;
 767                         if (!use_fpstack && list) {
 768                                 while (list) {
 769                                         guint32 regpair;
 770                                         int reg, hreg;
 771
 772                                         regpair = (guint32)(gssize)(list->data);
 773                                         hreg = regpair >> 24;
 774                                         reg = regpair & 0xffffff;
 775
 776                                         reginfof [reg].prev_use = reginfof [reg].last_use;
 777                                         reginfof [reg].last_use = i;
 778
 779                                         list = g_slist_next (list);
 780                                 }
 781                         }
 782                 }
 783
 784                 reversed = inst_list_prepend (cfg->mempool, reversed, ins);
 785                 ++i;
 786                 ins = ins->next;
 787         }
 788
 789         // todo: check if we have anything left on fp stack, in verify mode?
 790         fspill = 0;
 791
 792         DEBUG (print_regtrack (reginfo, rs->next_vireg));
 793         DEBUG (print_regtrack (reginfof, rs->next_vfreg));
 794         tmp = reversed;
 795         while (tmp) {
 796                 int prev_dreg, prev_sreg1, prev_sreg2, clob_dreg;
 797                 int dest_dreg, dest_sreg1, dest_sreg2, clob_reg;
 798                 int dreg_high, sreg1_high;
 799                 guint32 dreg_mask, sreg1_mask, sreg2_mask, mask;
 800                 --i;
 801                 ins = tmp->data;
 802                 spec = ins_spec [ins->opcode];
 803                 prev_dreg = -1;
 804                 clob_dreg = -1;
 805                 clob_reg = -1;
 806                 dest_dreg = -1;
 807                 dest_sreg1 = -1;
 808                 dest_sreg2 = -1;
 809                 dreg_mask = dreg_is_fp (ins) ? MONO_ARCH_CALLEE_FREGS : MONO_ARCH_CALLEE_REGS;
 810                 sreg1_mask = sreg1_is_fp (ins) ? MONO_ARCH_CALLEE_FREGS : MONO_ARCH_CALLEE_REGS;
 811                 sreg2_mask = sreg2_is_fp (ins) ? MONO_ARCH_CALLEE_FREGS : MONO_ARCH_CALLEE_REGS;
 812
 813                 DEBUG (g_print ("processing:"));
 814                 DEBUG (print_ins (i, ins));
 815
 816                 /*
 817                  * FIXED REGS
 818                  */
 819                 dest_sreg1 = MONO_ARCH_INST_FIXED_REG (spec [MONO_INST_SRC1]);
 820                 dest_sreg2 = MONO_ARCH_INST_FIXED_REG (spec [MONO_INST_SRC2]);
 821                 dest_dreg = MONO_ARCH_INST_FIXED_REG (spec [MONO_INST_DEST]);
 822                 clob_reg = MONO_ARCH_INST_FIXED_REG (spec [MONO_INST_CLOB]);
 823                 sreg2_mask &= ~ (MONO_ARCH_INST_SREG2_MASK (spec));
 824
 825                 /*
 826                  * TRACK FP STACK
 827                  */
 828                 if (use_fpstack && (spec [MONO_INST_CLOB] != 'm')) {
 829                         if (dreg_is_fp (ins)) {
 830                                 if (reginfof [ins->dreg].flags & MONO_FP_NEEDS_SPILL) {
 831                                         GList *spill_node;
 832                                         MonoInst *store;
 833                                         spill_node = g_list_first (fspill_list);
 834                                         g_assert (spill_node);
 835
 836                                         store = create_spilled_store_float (cfg, GPOINTER_TO_INT (spill_node->data), ins->dreg, ins);
 837                                         insert_before_ins (ins, tmp, store);
 838                                         fspill_list = g_list_remove (fspill_list, spill_node->data);
 839                                         fspill--;
 840                                 }
 841                         }
 842
 843                         if (spec [MONO_INST_SRC1] == 'f') {
 844                                 if (reginfof [ins->sreg1].flags & MONO_FP_NEEDS_LOAD) {
 845                                         MonoInst *load;
 846                                         MonoInst *store = NULL;
 847
 848                                         if (reginfof [ins->sreg1].flags & MONO_FP_NEEDS_LOAD_SPILL) {
 849                                                 GList *spill_node;
 850                                                 spill_node = g_list_first (fspill_list);
 851                                                 g_assert (spill_node);
 852
 853                                                 store = create_spilled_store_float (cfg, GPOINTER_TO_INT (spill_node->data), ins->sreg1, ins);
 854                                                 fspill_list = g_list_remove (fspill_list, spill_node->data);
 855                                         }
 856
 857                                         fspill++;
 858                                         fspill_list = g_list_prepend (fspill_list, GINT_TO_POINTER(fspill));
 859                                         load = create_spilled_load_float (cfg, fspill, ins->sreg1, ins);
 860                                         insert_before_ins (ins, tmp, load);
 861                                         if (store)
 862                                                 insert_before_ins (load, tmp, store);
 863                                 }
 864                         }
 865
 866                         if (spec [MONO_INST_SRC2] == 'f') {
 867                                 if (reginfof [ins->sreg2].flags & MONO_FP_NEEDS_LOAD) {
 868                                         MonoInst *load;
 869                                         MonoInst *store = NULL;
 870
 871                                         if (reginfof [ins->sreg2].flags & MONO_FP_NEEDS_LOAD_SPILL) {
 872                                                 GList *spill_node;
 873
 874                                                 spill_node = g_list_first (fspill_list);
 875                                                 g_assert (spill_node);
 876                                                 if (spec [MONO_INST_SRC1] == 'f' && (reginfof [ins->sreg2].flags & MONO_FP_NEEDS_LOAD_SPILL))
 877                                                         spill_node = g_list_next (spill_node);
 878
 879                                                 store = create_spilled_store_float (cfg, GPOINTER_TO_INT (spill_node->data), ins->sreg2, ins);
 880                                                 fspill_list = g_list_remove (fspill_list, spill_node->data);
 881                                         }
 882
 883                                         fspill++;
 884                                         fspill_list = g_list_prepend (fspill_list, GINT_TO_POINTER(fspill));
 885                                         load = create_spilled_load_float (cfg, fspill, ins->sreg2, ins);
 886                                         insert_before_ins (ins, tmp, load);
 887                                         if (store)
 888                                                 insert_before_ins (load, tmp, store);
 889                                 }
 890                         }
 891                 }
 892
 893                 /*
 894                  * TRACK FIXED SREG2
 895                  */
 896                 if (dest_sreg2 != -1) {
 897                         if (rs->ifree_mask & (1 << dest_sreg2)) {
 898                                 if (is_global_ireg (ins->sreg2)) {
 899                                         /* Argument already in hard reg, need to copy */
 900                                         MonoInst *copy = create_copy_ins (cfg, dest_sreg2, ins->sreg2, NULL, FALSE);
 901                                         insert_before_ins (ins, tmp, copy);
 902                                 }
 903                                 else {
 904                                         DEBUG (g_print ("\tshortcut assignment of R%d to %s\n", ins->sreg2, mono_arch_regname (dest_sreg2)));
 905                                         assign_ireg (rs, ins->sreg2, dest_sreg2);
 906                                 }
 907                         } else {
 908                                 int need_spill = TRUE;
 909
 910                                 dreg_mask &= ~ (1 << dest_sreg2);
 911                                 sreg1_mask &= ~ (1 << dest_sreg2);
 912
 913                                 /*
 914                                  * First check if dreg is assigned to dest_sreg2, since we
 915                                  * can't spill a dreg.
 916                                  */
 917                                 val = rs->iassign [ins->dreg];
 918                                 if (val == dest_sreg2 && ins->dreg != ins->sreg2) {
 919                                         /*
 920                                          * the destination register is already assigned to
 921                                          * dest_sreg2: we need to allocate another register for it
 922                                          * and then copy from this to dest_sreg2.
 923                                          */
 924                                         int new_dest;
 925                                         new_dest = alloc_int_reg (cfg, tmp, ins, dreg_mask, ins->dreg, &reginfo [ins->dreg]);
 926                                         g_assert (new_dest >= 0);
 927                                         DEBUG (g_print ("\tchanging dreg R%d to %s from %s\n", ins->dreg, mono_arch_regname (new_dest), mono_arch_regname (dest_sreg2)));
 928
 929                                         prev_dreg = ins->dreg;
 930                                         assign_ireg (rs, ins->dreg, new_dest);
 931                                         clob_dreg = ins->dreg;
 932                                         create_copy_ins (cfg, dest_sreg2, new_dest, ins, FALSE);
 933                                         need_spill = FALSE;
 934                                 }
 935
 936                                 if (is_global_ireg (ins->sreg2)) {
 937                                         MonoInst *copy = create_copy_ins (cfg, dest_sreg2, ins->sreg2, NULL, FALSE);
 938                                         insert_before_ins (ins, tmp, copy);
 939                                 }
 940                                 else {
 941                                         val = rs->iassign [ins->sreg2];
 942                                         if (val == dest_sreg2) {
 943                                                 /* sreg2 is already assigned to the correct register */
 944                                                 need_spill = FALSE;
 945                                         }
 946                                         else if ((val >= 0) || (val < -1)) {
 947                                                 /* FIXME: sreg2 already assigned to another register */
 948                                                 g_assert_not_reached ();
 949                                         }
 950                                 }
 951
 952                                 if (need_spill) {
 953                                         DEBUG (g_print ("\tforced spill of R%d\n", rs->isymbolic [dest_sreg2]));
 954                                         get_register_force_spilling (cfg, tmp, ins, rs->isymbolic [dest_sreg2], FALSE);
 955                                         mono_regstate_free_int (rs, dest_sreg2);
 956                                 }
 957
 958                                 if (!is_global_ireg (ins->sreg2))
 959                                         /* force-set sreg2 */
 960                                         assign_ireg (rs, ins->sreg2, dest_sreg2);
 961                         }
 962                         ins->sreg2 = dest_sreg2;
 963                 }
 964
 965                 /*
 966                  * TRACK DREG
 967                  */
 968                 fp = dreg_is_fp (ins);
 969                 if (spec [MONO_INST_DEST] && (!fp || (fp && !use_fpstack)) && is_soft_reg (ins->dreg, fp))
 970                         prev_dreg = ins->dreg;
 971
 972                 /*
 973                  * If dreg is a fixed regpair, free up both of the needed hregs to avoid
 974                  * various complex situations.
 975                  */
 976                 if (MONO_ARCH_INST_IS_REGPAIR (spec [MONO_INST_DEST])) {
 977                         guint32 dreg2, dest_dreg2;
 978
 979                         g_assert (is_soft_reg (ins->dreg, fp));
 980
 981                         if (dest_dreg != -1) {
 982                                 if (rs->iassign [ins->dreg] != dest_dreg)
 983                                         free_up_ireg (cfg, tmp, ins, dest_dreg);
 984
 985                                 dreg2 = ins->dreg + 1;
 986                                 dest_dreg2 = MONO_ARCH_INST_REGPAIR_REG2 (spec [MONO_INST_DEST], dest_dreg);
 987                                 if (dest_dreg2 != -1) {
 988                                         if (rs->iassign [dreg2] != dest_dreg2)
 989                                                 free_up_ireg (cfg, tmp, ins, dest_dreg2);
 990                                 }
 991                         }
 992                 }
 993
 994                 if ((!fp || (fp && !use_fpstack)) && (is_soft_reg (ins->dreg, fp))) {
 995                         if (dest_dreg != -1)
 996                                 dreg_mask = (1 << dest_dreg);
 997
 998                         val = rassign (cfg, ins->dreg, fp);
 999
1000                         if (val < 0) {
1001                                 int spill = 0;
1002                                 if (val < -1) {
1003                                         /* the register gets spilled after this inst */
1004                                         spill = -val -1;
1005                                 }
1006                                 val = alloc_reg (cfg, tmp, ins, dreg_mask, ins->dreg, &reginfo [ins->dreg], fp);
1007                                 assign_reg (rs, ins->dreg, val, fp);
1008                                 if (spill)
1009                                         create_spilled_store (cfg, spill, val, prev_dreg, ins, fp);
1010                         }
1011
1012                         DEBUG (g_print ("\tassigned dreg %s to dest R%d\n", mono_regname_full (val, fp), ins->dreg));
1013                         ins->dreg = val;
1014                 }
1015
1016                 /* Handle regpairs */
1017                 if (MONO_ARCH_INST_IS_REGPAIR (spec [MONO_INST_DEST])) {
1018                         int reg2 = prev_dreg + 1;
1019
1020                         g_assert (!fp);
1021                         g_assert (prev_dreg > -1);
1022                         g_assert (!is_global_ireg (rs->iassign [prev_dreg]));
1023                         mask = regpair_reg2_mask (spec [MONO_INST_DEST], rs->iassign [prev_dreg]);
1024                         val = rs->iassign [reg2];
1025                         if (val < 0) {
1026                                 int spill = 0;
1027                                 if (val < -1) {
1028                                         /* the register gets spilled after this inst */
1029                                         spill = -val -1;
1030                                 }
1031                                 val = mono_regstate_alloc_int (rs, mask);
1032                                 if (val < 0)
1033                                         val = get_register_spilling (cfg, tmp, ins, mask, reg2, fp);
1034                                 if (spill)
1035                                         create_spilled_store (cfg, spill, val, reg2, ins, fp);
1036                         }
1037                         else {
1038                                 if (! (mask & (1 << val))) {
1039                                         val = mono_regstate_alloc_int (rs, mask);
1040                                         if (val < 0)
1041                                                 val = get_register_spilling (cfg, tmp, ins, mask, reg2, fp);
1042
1043                                         /* Reallocate hreg to the correct register */
1044                                         create_copy_ins (cfg, rs->iassign [reg2], val, ins, fp);
1045
1046                                         mono_regstate_free_int (rs, rs->iassign [reg2]);
1047                                 }
1048                         }
1049
1050                         DEBUG (g_print ("\tassigned dreg-high %s to dest R%d\n", mono_arch_regname (val), reg2));
1051                         assign_reg (rs, reg2, val, fp);
1052
1053                         dreg_high = val;
1054                         ins->unused = val;
1055
1056                         if (reg_is_freeable (val, fp) && reg2 >= 0 && (reginfo [reg2].born_in >= i)) {
1057                                 DEBUG (g_print ("\tfreeable %s (R%d)\n", mono_arch_regname (val), reg2));
1058                                 mono_regstate_free_int (rs, val);
1059                         }
1060                 }
1061
1062                 if ((!fp || (fp && !use_fpstack)) && prev_dreg >= 0 && is_soft_reg (prev_dreg, fp) && (fp ? reginfof : reginfo) [prev_dreg].born_in >= i) {
1063                         /*
1064                          * In theory, we could free up the hreg even if the vreg is alive,
1065                          * but branches inside bblocks force us to assign the same hreg
1066                          * to a vreg every time it is encountered.
1067                          */
1068                         int dreg = rassign (cfg, prev_dreg, fp);
1069                         g_assert (dreg >= 0);
1070                         DEBUG (g_print ("\tfreeable %s (R%d) (born in %d)\n", mono_regname_full (dreg, fp), prev_dreg, (fp ? reginfof : reginfo) [prev_dreg].born_in));
1071                         if (fp)
1072                                 mono_regstate_free_float (rs, dreg);
1073                         else
1074                                 mono_regstate_free_int (rs, dreg);
1075                 }
1076
1077                 if ((dest_dreg != -1) && (ins->dreg != dest_dreg)) {
1078                         /* this instruction only outputs to dest_dreg, need to copy */
1079                         create_copy_ins (cfg, ins->dreg, dest_dreg, ins, fp);
1080                         ins->dreg = dest_dreg;
1081
1082                         if (fp) {
1083                                 if (rs->fsymbolic [dest_dreg] >= MONO_MAX_FREGS)
1084                                         free_up_reg (cfg, tmp, ins, dest_dreg, fp);
1085                         }
1086                         else {
1087                                 if (rs->isymbolic [dest_dreg] >= MONO_MAX_IREGS)
1088                                         free_up_reg (cfg, tmp, ins, dest_dreg, fp);
1089                         }
1090                 }
1091
1092                 /*
1093                  * TRACK CLOBBERING
1094                  */
1095                 if ((clob_reg != -1) && (!(rs->ifree_mask & (1 << clob_reg)))) {
1096                         DEBUG (g_print ("\tforced spill of clobbered reg R%d\n", rs->isymbolic [clob_reg]));
1097                         get_register_force_spilling (cfg, tmp, ins, rs->isymbolic [clob_reg], FALSE);
1098                         mono_regstate_free_int (rs, clob_reg);
1099                 }
1100
1101                 if (spec [MONO_INST_CLOB] == 'c') {
1102                         int j, s, dreg, dreg2;
1103                         guint64 clob_mask;
1104
1105                         clob_mask = MONO_ARCH_CALLEE_REGS;
1106
1107                         /*
1108                          * Need to avoid spilling the dreg since the dreg is not really
1109                          * clobbered by the call.
1110                          */
1111                         if ((prev_dreg != -1) && !dreg_is_fp (ins))
1112                                 dreg = rassign (cfg, prev_dreg, dreg_is_fp (ins));
1113                         else
1114                                 dreg = -1;
1115
1116                         if (MONO_ARCH_INST_IS_REGPAIR (spec [MONO_INST_DEST]))
1117                                 dreg2 = rassign (cfg, prev_dreg + 1, dreg_is_fp (ins));
1118                         else
1119                                 dreg2 = -1;
1120
1121                         for (j = 0; j < MONO_MAX_IREGS; ++j) {
1122                                 s = 1 << j;
1123                                 if ((clob_mask & s) && !(rs->ifree_mask & s) && (j != ins->sreg1) && (j != dreg) && (j != dreg2)) {
1124                                         get_register_force_spilling (cfg, tmp, ins, rs->isymbolic [j], FALSE);
1125                                         mono_regstate_free_int (rs, j);
1126                                 }
1127                         }
1128
1129                         if (!use_fpstack) {
1130                                 clob_mask = MONO_ARCH_CALLEE_FREGS;
1131                                 if ((prev_dreg != -1) && dreg_is_fp (ins))
1132                                         dreg = rassign (cfg, prev_dreg, dreg_is_fp (ins));
1133                                 else
1134                                         dreg = -1;
1135
1136                                 for (j = 0; j < MONO_MAX_FREGS; ++j) {
1137                                         s = 1 << j;
1138                                         if ((clob_mask & s) && !(rs->ffree_mask & s) && (j != ins->sreg1) && (j != dreg)) {
1139                                                 get_register_force_spilling (cfg, tmp, ins, rs->fsymbolic [j], TRUE);
1140                                                 mono_regstate_free_float (rs, j);
1141                                         }
1142                                 }
1143                         }
1144                 }
1145
1146                 /*
1147                  * TRACK ARGUMENT REGS
1148                  */
1149                 if (spec [MONO_INST_CLOB] == 'c') {
1150                         MonoCallInst *call = (MonoCallInst*)ins;
1151                         GSList *list;
1152
1153                         /*
1154                          * This needs to be done before assigning sreg1, so sreg1 will
1155                          * not be assigned one of the argument regs.
1156                          */
1157
1158                         /*
1159                          * Assign all registers in call->out_reg_args to the proper
1160                          * argument registers.
1161                          */
1162
1163                         list = call->out_ireg_args;
1164                         if (list) {
1165                                 while (list) {
1166                                         guint32 regpair;
1167                                         int reg, hreg;
1168
1169                                         regpair = (guint32)(gssize)(list->data);
1170                                         hreg = regpair >> 24;
1171                                         reg = regpair & 0xffffff;
1172
1173                                         assign_reg (rs, reg, hreg, FALSE);
1174
1175                                         sreg1_mask &= ~(1 << hreg);
1176
1177                                         DEBUG (g_print ("\tassigned arg reg %s to R%d\n", mono_arch_regname (hreg), reg));
1178
1179                                         list = g_slist_next (list);
1180                                 }
1181                                 g_slist_free (call->out_ireg_args);
1182                         }
1183
1184                         list = call->out_freg_args;
1185                         if (list && !use_fpstack) {
1186                                 while (list) {
1187                                         guint32 regpair;
1188                                         int reg, hreg;
1189
1190                                         regpair = (guint32)(gssize)(list->data);
1191                                         hreg = regpair >> 24;
1192                                         reg = regpair & 0xffffff;
1193
1194                                         assign_reg (rs, reg, hreg, TRUE);
1195
1196                                         DEBUG (g_print ("\tassigned arg reg %s to R%d\n", mono_arch_fregname (hreg), reg));
1197
1198                                         list = g_slist_next (list);
1199                                 }
1200                         }
1201                         if (call->out_freg_args)
1202                                 g_slist_free (call->out_freg_args);
1203                 }
1204
1205                 /*
1206                  * TRACK SREG1
1207                  */
1208                 fp = sreg1_is_fp (ins);
1209                 if ((!fp || (fp && !use_fpstack))) {
1210                         if (MONO_ARCH_INST_IS_REGPAIR (spec [MONO_INST_DEST]) && (spec [MONO_INST_CLOB] == '1')) {
1211                                 g_assert (is_soft_reg (ins->sreg1, fp));
1212
1213                                 /* To simplify things, we allocate the same regpair to sreg1 and dreg */
1214                                 if (dest_sreg1 != -1)
1215                                         g_assert (dest_sreg1 == ins->dreg);
1216                                 val = mono_regstate_alloc_int (rs, 1 << ins->dreg);
1217                                 g_assert (val >= 0);
1218                                 assign_reg (rs, ins->sreg1, val, fp);
1219
1220                                 DEBUG (g_print ("\tassigned sreg1-low %s to R%d\n", mono_regname_full (val, fp), ins->sreg1));
1221
1222                                 g_assert ((1 << dreg_high) & regpair_reg2_mask (spec [MONO_INST_SRC1], ins->dreg));
1223                                 val = mono_regstate_alloc_int (rs, 1 << dreg_high);
1224                                 g_assert (val >= 0);
1225                                 assign_reg (rs, ins->sreg1 + 1, val, fp);
1226
1227                                 DEBUG (g_print ("\tassigned sreg1-high %s to R%d\n", mono_regname_full (val, fp), ins->sreg1 + 1));
1228
1229                                 /* Skip rest of this section */
1230                                 dest_sreg1 = -1;
1231                         }
1232
1233                         if (dest_sreg1 != -1) {
1234                                 sreg1_mask = 1 << dest_sreg1;
1235
1236                                 if (!(rs->ifree_mask & (1 << dest_sreg1))) {
1237                                         DEBUG (g_print ("\tforced spill of R%d\n", rs->isymbolic [dest_sreg1]));
1238                                         get_register_force_spilling (cfg, tmp, ins, rs->isymbolic [dest_sreg1], FALSE);
1239                                         mono_regstate_free_int (rs, dest_sreg1);
1240                                 }
1241                                 if (is_global_ireg (ins->sreg1)) {
1242                                         /* The argument is already in a hard reg, need to copy */
1243                                         MonoInst *copy = create_copy_ins (cfg, dest_sreg1, ins->sreg1, NULL, FALSE);
1244                                         insert_before_ins (ins, tmp, copy);
1245                                         ins->sreg1 = dest_sreg1;
1246                                 }
1247                         }
1248
1249                         if (is_soft_reg (ins->sreg1, fp)) {
1250                                 val = rassign (cfg, ins->sreg1, fp);
1251                                 prev_sreg1 = ins->sreg1;
1252                                 if (val < 0) {
1253                                         int spill = 0;
1254                                         if (val < -1) {
1255                                                 /* the register gets spilled after this inst */
1256                                                 spill = -val -1;
1257                                         }
1258
1259                                         if (((ins->opcode == OP_MOVE) || (ins->opcode == OP_SETREG)) && !spill && !fp && (!is_global_ireg (ins->dreg) && (rs->ifree_mask & (1 << ins->dreg)))) {
1260                                                 /*
1261                                                  * Allocate the same hreg to sreg1 as well so the
1262                                                  * peephole can get rid of the move.
1263                                                  */
1264                                                 sreg1_mask = 1 << ins->dreg;
1265                                         }
1266
1267                                         val = alloc_reg (cfg, tmp, ins, sreg1_mask, ins->sreg1, &reginfo [ins->sreg1], fp);
1268                                         assign_reg (rs, ins->sreg1, val, fp);
1269                                         DEBUG (g_print ("\tassigned sreg1 %s to R%d\n", mono_regname_full (val, fp), ins->sreg1));
1270
1271                                         if (spill) {
1272                                                 MonoInst *store = create_spilled_store (cfg, spill, val, prev_sreg1, NULL, fp);
1273                                                 /*
1274                                                  * Need to insert before the instruction since it can
1275                                                  * overwrite sreg1.
1276                                                  */
1277                                                 insert_before_ins (ins, tmp, store);
1278                                         }
1279                                 }
1280                                 else if ((dest_sreg1 != -1) && (dest_sreg1 != val)) {
1281                                         g_assert_not_reached ();
1282                                 }
1283
1284                                 ins->sreg1 = val;
1285                         }
1286                         else {
1287                                 prev_sreg1 = -1;
1288                         }
1289                         sreg2_mask &= ~(1 << ins->sreg1);
1290                 }
1291
1292                 /* Handle the case when sreg1 is a regpair but dreg is not */
1293                 if (MONO_ARCH_INST_IS_REGPAIR (spec [MONO_INST_SRC1]) && (spec [MONO_INST_CLOB] != '1')) {
1294                         int reg2 = prev_sreg1 + 1;
1295
1296                         g_assert (!fp);
1297                         g_assert (prev_sreg1 > -1);
1298                         g_assert (!is_global_ireg (rs->iassign [prev_sreg1]));
1299                         mask = regpair_reg2_mask (spec [MONO_INST_SRC1], rs->iassign [prev_sreg1]);
1300                         val = rs->iassign [reg2];
1301                         if (val < 0) {
1302                                 int spill = 0;
1303                                 if (val < -1) {
1304                                         /* the register gets spilled after this inst */
1305                                         spill = -val -1;
1306                                 }
1307                                 val = mono_regstate_alloc_int (rs, mask);
1308                                 if (val < 0)
1309                                         val = get_register_spilling (cfg, tmp, ins, mask, reg2, fp);
1310                                 if (spill)
1311                                         g_assert_not_reached ();
1312                         }
1313                         else {
1314                                 if (! (mask & (1 << val))) {
1315                                         /* The vreg is already allocated to a wrong hreg */
1316                                         /* FIXME: */
1317                                         g_assert_not_reached ();
1318 #if 0
1319                                         val = mono_regstate_alloc_int (rs, mask);
1320                                         if (val < 0)
1321                                                 val = get_register_spilling (cfg, tmp, ins, mask, reg2, fp);
1322
1323                                         /* Reallocate hreg to the correct register */
1324                                         create_copy_ins (cfg, rs->iassign [reg2], val, ins, fp);
1325
1326                                         mono_regstate_free_int (rs, rs->iassign [reg2]);
1327 #endif
1328                                 }
1329                         }
1330
1331                         sreg1_high = val;
1332                         DEBUG (g_print ("\tassigned sreg1 hreg %s to dest R%d\n", mono_arch_regname (val), reg2));
1333                         assign_reg (rs, reg2, val, fp);
1334                 }
1335
1336                 /* Handle dreg==sreg1 */
1337                 if (((dreg_is_fp (ins) && spec [MONO_INST_SRC1] == 'f' && !use_fpstack) || spec [MONO_INST_CLOB] == '1') && ins->dreg != ins->sreg1) {
1338                         MonoInst *sreg2_copy = NULL;
1339                         MonoInst *copy;
1340                         gboolean fp = (spec [MONO_INST_SRC1] == 'f');
1341
1342                         if (ins->dreg == ins->sreg2) {
1343                                 /*
1344                                  * copying sreg1 to dreg could clobber sreg2, so allocate a new
1345                                  * register for it.
1346                                  */
1347                                 int reg2 = alloc_reg (cfg, tmp, ins, dreg_mask, ins->sreg2, NULL, fp);
1348
1349                                 DEBUG (g_print ("\tneed to copy sreg2 %s to reg %s\n", mono_regname_full (ins->sreg2, fp), mono_regname_full (reg2, fp)));
1350                                 sreg2_copy = create_copy_ins (cfg, reg2, ins->sreg2, NULL, fp);
1351                                 prev_sreg2 = ins->sreg2 = reg2;
1352
1353                                 if (fp)
1354                                         mono_regstate_free_float (rs, reg2);
1355                                 else
1356                                         mono_regstate_free_int (rs, reg2);
1357                         }
1358
1359                         if (MONO_ARCH_INST_IS_REGPAIR (spec [MONO_INST_SRC1])) {
1360                                 /* Copying sreg1_high to dreg could also clobber sreg2 */
1361                                 if (rs->iassign [prev_sreg1 + 1] == ins->sreg2)
1362                                         /* FIXME: */
1363                                         g_assert_not_reached ();
1364
1365                                 /*
1366                                  * sreg1 and dest are already allocated to the same regpair by the
1367                                  * SREG1 allocation code.
1368                                  */
1369                                 g_assert (ins->sreg1 == ins->dreg);
1370                                 g_assert (dreg_high == sreg1_high);
1371                         }
1372
1373                         DEBUG (g_print ("\tneed to copy sreg1 %s to dreg %s\n", mono_regname_full (ins->sreg1, fp), mono_regname_full (ins->dreg, fp)));
1374                         copy = create_copy_ins (cfg, ins->dreg, ins->sreg1, NULL, fp);
1375                         insert_before_ins (ins, tmp, copy);
1376
1377                         if (sreg2_copy)
1378                                 insert_before_ins (copy, tmp, sreg2_copy);
1379
1380                         /*
1381                          * Need to prevent sreg2 to be allocated to sreg1, since that
1382                          * would screw up the previous copy.
1383                          */
1384                         sreg2_mask &= ~ (1 << ins->sreg1);
1385                         /* we set sreg1 to dest as well */
1386                         prev_sreg1 = ins->sreg1 = ins->dreg;
1387                         sreg2_mask &= ~ (1 << ins->dreg);
1388                 }
1389
1390                 /*
1391                  * TRACK SREG2
1392                  */
1393                 fp = sreg2_is_fp (ins);
1394                 if (MONO_ARCH_INST_IS_REGPAIR (spec [MONO_INST_SRC2]))
1395                         g_assert_not_reached ();
1396                 if ((!fp || (fp && !use_fpstack)) && (is_soft_reg (ins->sreg2, fp))) {
1397                         val = rassign (cfg, ins->sreg2, fp);
1398
1399                         if (val < 0) {
1400                                 int spill = 0;
1401                                 if (val < -1) {
1402                                         /* the register gets spilled after this inst */
1403                                         spill = -val -1;
1404                                 }
1405                                 val = alloc_reg (cfg, tmp, ins, sreg2_mask, ins->sreg2, &reginfo [ins->sreg2], fp);
1406                                 assign_reg (rs, ins->sreg2, val, fp);
1407                                 DEBUG (g_print ("\tassigned sreg2 %s to R%d\n", mono_regname_full (val, fp), ins->sreg2));
1408                                 if (spill)
1409                                         create_spilled_store (cfg, spill, val, prev_sreg2, ins, fp);
1410                         }
1411                         ins->sreg2 = val;
1412                 }
1413                 else {
1414                         prev_sreg2 = -1;
1415                 }
1416
1417                 /*if (reg_is_freeable (ins->sreg1) && prev_sreg1 >= 0 && reginfo [prev_sreg1].born_in >= i) {
1418                         DEBUG (g_print ("freeable %s\n", mono_arch_regname (ins->sreg1)));
1419                         mono_regstate_free_int (rs, ins->sreg1);
1420                 }
1421                 if (reg_is_freeable (ins->sreg2) && prev_sreg2 >= 0 && reginfo [prev_sreg2].born_in >= i) {
1422                         DEBUG (g_print ("freeable %s\n", mono_arch_regname (ins->sreg2)));
1423                         mono_regstate_free_int (rs, ins->sreg2);
1424                 }*/
1425
1426                 DEBUG (print_ins (i, ins));
1427                 /* this may result from a insert_before call */
1428                 if (!tmp->next)
1429                         bb->code = tmp->data;
1430                 tmp = tmp->next;
1431         }
1432
1433         g_free (reginfo);
1434         g_free (reginfof);
1435         g_list_free (fspill_list);
1436 }