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->fassign);
  25         g_free (rs);
  26 }
  27
  28 void
  29 mono_regstate_reset (MonoRegState *rs) {
  30         rs->next_vireg = MONO_MAX_IREGS;
  31         rs->next_vfreg = MONO_MAX_FREGS;
  32 }
  33
  34 void
  35 mono_regstate_assign (MonoRegState *rs) {
  36         int i;
  37         g_free (rs->iassign);
  38         rs->iassign = g_malloc (MAX (MONO_MAX_IREGS, rs->next_vireg) * sizeof (int));
  39         for (i = 0; i < MONO_MAX_IREGS; ++i) {
  40                 rs->iassign [i] = i;
  41                 rs->isymbolic [i] = 0;
  42         }
  43         for (; i < rs->next_vireg; ++i)
  44                 rs->iassign [i] = -1;
  45
  46         g_free (rs->fassign);
  47         rs->fassign = g_malloc (MAX (MONO_MAX_FREGS, rs->next_vfreg) * sizeof (int));
  48         for (i = 0; i < MONO_MAX_FREGS; ++i) {
  49                 rs->fassign [i] = i;
  50                 rs->fsymbolic [i] = 0;
  51         }
  52         for (; i < rs->next_vfreg; ++i)
  53                 rs->fassign [i] = -1;
  54 }
  55
  56 int
  57 mono_regstate_alloc_int (MonoRegState *rs, regmask_t allow)
  58 {
  59         int i;
  60         regmask_t mask = allow & rs->ifree_mask;
  61         for (i = 0; i < MONO_MAX_IREGS; ++i) {
  62                 if (mask & (1 << i)) {
  63                         rs->ifree_mask &= ~ (1 << i);
  64                         return i;
  65                 }
  66         }
  67         return -1;
  68 }
  69
  70 void
  71 mono_regstate_free_int (MonoRegState *rs, int reg)
  72 {
  73         if (reg >= 0) {
  74                 rs->ifree_mask |= 1 << reg;
  75                 rs->isymbolic [reg] = 0;
  76         }
  77 }
  78
  79 int
  80 mono_regstate_alloc_float (MonoRegState *rs, regmask_t allow)
  81 {
  82         int i;
  83         regmask_t mask = allow & rs->ffree_mask;
  84         for (i = 0; i < MONO_MAX_FREGS; ++i) {
  85                 if (mask & (1 << i)) {
  86                         rs->ffree_mask &= ~ (1 << i);
  87                         return i;
  88                 }
  89         }
  90         return -1;
  91 }
  92
  93 void
  94 mono_regstate_free_float (MonoRegState *rs, int reg)
  95 {
  96         if (reg >= 0) {
  97                 rs->ffree_mask |= 1 << reg;
  98                 rs->fsymbolic [reg] = 0;
  99         }
 100 }
 101
 102 inline int
 103 mono_regstate_next_long (MonoRegState *rs)
 104 {
 105         int rval = rs->next_vireg;
 106
 107         rs->next_vireg += 2;
 108
 109         return rval;
 110 }
 111