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 1024
  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 0
  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_is_reg_allocatable(const ir_node *irn, const arch_register_t *reg)
  82 {
  83   return arch_register_get_class(reg) == firm_get_irn_reg_class(irn);
  84 }
  85
  86 static int firm_get_allocatable_regs(const ir_node *irn,
  87     const arch_register_class_t *cls, bitset_t *bs)
  88 {
  89   int i;
  90
  91   if(firm_get_irn_reg_class(irn) != cls) {
  92     bitset_clear_all(bs);
  93     return 0;
  94   }
  95
  96   for(i = 0; i < cls->n_regs; ++i)
  97     bitset_set_all(bs);
  98
  99   return cls->n_regs;
 100 }
 101
 102 const arch_isa_if_t arch_isa_if_firm = {
 103   firm_init,
 104   firm_get_n_reg_class,
 105   firm_get_reg_class,
 106   firm_is_reg_allocatable,
 107   firm_get_allocatable_regs,
 108   firm_get_irn_reg_class,
 109   NULL
 110 };