nsz Git - libfirm/blob - ir/be/bearch_firm.c

   1
   2 /**
   3  * ISA implementation for Firm IR nodes.
   4  */
   5
   6 #include "bitset.h"
   7 #include "bearch.h"
   8
   9 #define N_REGS 64
  10
  11 static arch_register_t gp_regs[N_REGS];
  12 static arch_register_t fp_regs[N_REGS];
  13
  14 static arch_register_class_t reg_classes[] = {
  15   { "gp", NULL, N_REGS, gp_regs },
  16   { "fp", NULL, N_REGS, fp_regs }
  17 };
  18
  19 #define N_CLASSES \
  20   (sizeof(reg_classes) / sizeof(reg_classes[0]))
  21
  22 #define CLS_GP 0
  23 #define CLS_FP 1
  24
  25 static void firm_init(void)
  26 {
  27   static struct obstack obst;
  28   static int inited = 0;
  29   int k;
  30
  31   if(inited)
  32     return;
  33
  34   inited = 1;
  35   obstack_init(&obst);
  36
  37   for(k = 0; k < N_CLASSES; ++k) {
  38     const arch_register_class_t *cls = &reg_classes[k];
  39     int i;
  40
  41     for(i = 0; i < cls->n_regs; ++i) {
  42       int n;
  43       char buf[8];
  44       char *name;
  45       arch_register_t *reg = (arch_register_t *) &cls->regs[i];
  46
  47       n = snprintf(buf, sizeof(buf), "r%d", i);
  48       name = obstack_copy0(&obst, buf, n);
  49
  50       reg->name = name;
  51       reg->reg_class = cls;
  52       reg->index = i;
  53       reg->type = 0;
  54     }
  55   }
  56 }
  57
  58 static int firm_get_n_reg_class(void)
  59 {
  60   return N_CLASSES;
  61 }
  62
  63 static const arch_register_class_t *firm_get_reg_class(int i)
  64 {
  65   assert(i >= 0 && i < N_CLASSES);
  66   return &reg_classes[i];
  67 }
  68
  69 static const arch_register_class_t *firm_get_irn_reg_class(const ir_node *irn)
  70 {
  71   ir_mode *mode = get_irn_mode(irn);
  72
  73   if(mode_is_float(mode))
  74     return &reg_classes[CLS_FP];
  75   else if(mode_is_datab(mode))
  76     return &reg_classes[CLS_GP];
  77
  78   return NULL;
  79 }
  80
  81 static int firm_get_allocatable_regs(const ir_node *irn,
  82     const arch_register_class_t *cls, bitset_t *bs)
  83 {
  84   int res = 0;
  85
  86   if(firm_get_irn_reg_class(irn) != cls) {
  87     if(bs)
  88       bitset_clear_all(bs);
  89   }
  90
  91   else {
  92     int i;
  93
  94     res = cls->n_regs;
  95     if(bs) {
  96       for(i = 0; i < cls->n_regs; ++i)
  97         bitset_set(bs, i);
  98     }
  99   }
 100
 101   return res;
 102 }
 103
 104 static int firm_is_reg_allocatable(const ir_node *irn, const arch_register_t *reg)
 105 {
 106         const arch_register_class_t *cls = reg->reg_class;
 107         ir_mode *irm = get_irn_mode(irn);
 108
 109         if(mode_is_float(irm))
 110                 return cls == &reg_classes[CLS_FP];
 111         else if(mode_is_datab(irm))
 112                 return cls == &reg_classes[CLS_GP];
 113
 114         return 0;
 115 }
 116
 117 const arch_isa_if_t arch_isa_if_firm = {
 118   firm_init,
 119   firm_get_n_reg_class,
 120   firm_get_reg_class,
 121   firm_get_allocatable_regs,
 122   firm_is_reg_allocatable,
 123   firm_get_irn_reg_class,
 124   NULL
 125 };