mono/mini/regalloc.c

   1 /*
   2  * regalloc.c: register state class
   3  *
   4  * Authors:
   5  *    Paolo Molaro (lupus@ximian.com)
   6  *
   7  * (C) 2003 Ximian, Inc.
   8  */
   9 #include "mini.h"
  10
  11 MonoRegState*
  12 mono_regstate_new (void)
  13 {
  14         MonoRegState* rs = g_new0 (MonoRegState, 1);
  15
  16         mono_regstate_reset (rs);
  17
  18         return rs;
  19 }
  20
  21 void
  22 mono_regstate_free (MonoRegState *rs) {
  23         g_free (rs->iassign);
  24         g_free (rs);
  25 }
  26
  27 void
  28 mono_regstate_reset (MonoRegState *rs) {
  29         rs->next_vireg = MONO_MAX_IREGS;
  30         rs->next_vfreg = MONO_MAX_FREGS;
  31 }
  32
  33 void
  34 mono_regstate_assign (MonoRegState *rs) {
  35         int i;
  36         g_free (rs->iassign);
  37         rs->iassign = g_malloc (MAX (MONO_MAX_IREGS, rs->next_vireg));
  38         for (i = 0; i < MONO_MAX_IREGS; ++i) {
  39                 rs->iassign [i] = i;
  40                 rs->isymbolic [i] = 0;
  41         }
  42         for (; i < rs->next_vireg; ++i)
  43                 rs->iassign [i] = -1;
  44
  45         rs->fassign = g_malloc (MAX (MONO_MAX_FREGS, rs->next_vfreg));
  46         for (i = 0; i < MONO_MAX_FREGS; ++i) {
  47                 rs->fassign [i] = i;
  48                 rs->fsymbolic [i] = 0;
  49         }
  50         for (; i < rs->next_vfreg; ++i)
  51                 rs->fassign [i] = -1;
  52 }
  53
  54 int
  55 mono_regstate_alloc_int (MonoRegState *rs, regmask_t allow)
  56 {
  57         int i;
  58         regmask_t mask = allow & rs->ifree_mask;
  59         for (i = 0; i < MONO_MAX_IREGS; ++i) {
  60                 if (mask & (1 << i)) {
  61                         rs->ifree_mask &= ~ (1 << i);
  62                         return i;
  63                 }
  64         }
  65         return -1;
  66 }
  67
  68 void
  69 mono_regstate_free_int (MonoRegState *rs, int reg)
  70 {
  71         if (reg >= 0) {
  72                 rs->ifree_mask |= 1 << reg;
  73                 rs->isymbolic [reg] = 0;
  74         }
  75 }
  76
  77 int
  78 mono_regstate_alloc_float (MonoRegState *rs, regmask_t allow)
  79 {
  80         int i;
  81         regmask_t mask = allow & rs->ffree_mask;
  82         for (i = 0; i < MONO_MAX_FREGS; ++i) {
  83                 if (mask & (1 << i)) {
  84                         rs->ffree_mask &= ~ (1 << i);
  85                         return i;
  86                 }
  87         }
  88         return -1;
  89 }
  90
  91 void
  92 mono_regstate_free_float (MonoRegState *rs, int reg)
  93 {
  94         if (reg >= 0) {
  95                 rs->ffree_mask |= 1 << reg;
  96                 rs->fsymbolic [reg] = 0;
  97         }
  98 }
  99
 100 inline int
 101 mono_regstate_next_long (MonoRegState *rs)
 102 {
 103         int rval = rs->next_vireg;
 104
 105         rs->next_vireg += 2;
 106
 107         return rval;
 108 }
 109