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

   1 /**
   2  * @file   beifg.c
   3  * @date   18.11.2005
   4  * @author Sebastian Hack
   5  *
   6  * Copyright (C) 2005 Universitaet Karlsruhe
   7  * Released under the GPL
   8  */
   9
  10 #include <stdlib.h>
  11
  12 #ifdef HAVE_CONFIG_H
  13 #include "config.h"
  14 #endif
  15
  16 #ifdef HAVE_MALLOC_H
  17 #include <malloc.h>
  18 #endif
  19
  20 #ifdef HAVE_ALLOCA_H
  21 #include <alloca.h>
  22 #endif
  23
  24 #include "irnode_t.h"
  25 #include "irprintf.h"
  26 #include "beifg_t.h"
  27
  28 size_t (be_ifg_nodes_iter_size)(const void *self)
  29 {
  30         const be_ifg_t *ifg = self;
  31         return ifg->impl->nodes_iter_size;
  32 }
  33
  34 size_t (be_ifg_neighbours_iter_size)(const void *self)
  35 {
  36         const be_ifg_t *ifg = self;
  37         return ifg->impl->neighbours_iter_size;
  38 }
  39
  40 size_t (be_ifg_cliques_iter_size)(const void *self)
  41 {
  42         const be_ifg_t *ifg = self;
  43         return ifg->impl->cliques_iter_size;
  44 }
  45
  46 void (be_ifg_free)(void *self)
  47 {
  48         be_ifg_t *ifg = self;
  49         ifg->impl->free(self);
  50 }
  51
  52 int (be_ifg_connected)(const void *self, const ir_node *a, const ir_node *b)
  53 {
  54         const be_ifg_t *ifg = self;
  55         return ifg->impl->connected(self, a, b);
  56 }
  57
  58 ir_node *(be_ifg_neighbours_begin)(const void *self, void *iter, const ir_node *irn)
  59 {
  60         const be_ifg_t *ifg = self;
  61         return ifg->impl->neighbours_begin(self, iter, irn);
  62 }
  63
  64 ir_node *(be_ifg_neighbours_next)(const void *self, void *iter)
  65 {
  66         const be_ifg_t *ifg = self;
  67         return ifg->impl->neighbours_next(self, iter);
  68 }
  69
  70 void (be_ifg_neighbours_break)(const void *self, void *iter)
  71 {
  72         const be_ifg_t *ifg = self;
  73         ifg->impl->neighbours_break(self, iter);
  74 }
  75
  76 ir_node *(be_ifg_nodes_begin)(const void *self, void *iter)
  77 {
  78         const be_ifg_t *ifg = self;
  79         return ifg->impl->nodes_begin(self, iter);
  80 }
  81
  82 ir_node *(be_ifg_nodes_next)(const void *self, void *iter)
  83 {
  84         const be_ifg_t *ifg = self;
  85         return ifg->impl->nodes_next(self, iter);
  86 }
  87
  88 void (be_ifg_nodes_break)(const void *self, void *iter)
  89 {
  90         const be_ifg_t *ifg = self;
  91         ifg->impl->nodes_break(self, iter);
  92 }
  93
  94 int (be_ifg_cliques_begin)(const void *self, void *iter, ir_node **buf)
  95 {
  96         const be_ifg_t *ifg = self;
  97         return ifg->impl->cliques_begin(self, iter, buf);
  98 }
  99
 100 int (be_ifg_cliques_next)(const void *self, void *iter)
 101 {
 102         const be_ifg_t *ifg = self;
 103         return ifg->impl->cliques_next(self, iter);
 104 }
 105
 106 void (be_ifg_cliques_break)(const void *self, void *iter)
 107 {
 108         const be_ifg_t *ifg = self;
 109         ifg->impl->cliques_break(self, iter);
 110 }
 111
 112 int (be_ifg_degree)(const void *self, const ir_node *irn)
 113 {
 114         const be_ifg_t *ifg = self;
 115         return ifg->impl->degree(self, irn);
 116 }
 117
 118
 119 int be_ifg_is_simplicial(const be_ifg_t *ifg, const ir_node *irn)
 120 {
 121         int degree = be_ifg_degree(ifg, irn);
 122         void *iter = be_ifg_neighbours_iter_alloca(ifg);
 123
 124         ir_node **neighbours = xmalloc(degree * sizeof(neighbours[0]));
 125
 126         ir_node *curr;
 127         int i, j;
 128
 129         be_ifg_foreach_neighbour(ifg, iter, irn, curr)
 130                 neighbours[i++] = curr;
 131
 132         for(i = 0; i < degree; ++i) {
 133                 for(j = 0; j < i; ++j)
 134                         if(!be_ifg_connected(ifg, neighbours[i], neighbours[j])) {
 135                                 free(neighbours);
 136                                 return 0;
 137                         }
 138         }
 139
 140
 141         free(neighbours);
 142         return 1;
 143 }
 144
 145 void be_ifg_check(const be_ifg_t *ifg)
 146 {
 147         void *iter1 = be_ifg_nodes_iter_alloca(ifg);
 148         void *iter2 = be_ifg_neighbours_iter_alloca(ifg);
 149
 150         ir_node *n, *m;
 151
 152         /* Check, if all neighbours are indeed connected to the node. */
 153         be_ifg_foreach_node(ifg, iter1, n) {
 154                 be_ifg_foreach_neighbour(ifg, iter2, n, m)
 155                         if(!be_ifg_connected(ifg, n, m))
 156                                 ir_fprintf(stderr, "%+F is a neighbour of %+F but they are not connected!\n", n, m);
 157         }
 158 }