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 void (be_ifg_free)(void *self)
  41 {
  42         be_ifg_t *ifg = self;
  43         ifg->impl->free(self);
  44 }
  45
  46 int (be_ifg_connected)(const void *self, const ir_node *a, const ir_node *b)
  47 {
  48         const be_ifg_t *ifg = self;
  49         return ifg->impl->connected(self, a, b);
  50 }
  51
  52 ir_node *(be_ifg_neighbours_begin)(const void *self, void *iter, const ir_node *irn)
  53 {
  54         const be_ifg_t *ifg = self;
  55         return ifg->impl->neighbours_begin(self, iter, irn);
  56 }
  57
  58 ir_node *(be_ifg_neighbours_next)(const void *self, void *iter)
  59 {
  60         const be_ifg_t *ifg = self;
  61         return ifg->impl->neighbours_next(self, iter);
  62 }
  63
  64 void (be_ifg_neighbours_break)(const void *self, void *iter)
  65 {
  66         const be_ifg_t *ifg = self;
  67         ifg->impl->neighbours_break(self, iter);
  68 }
  69
  70 ir_node *(be_ifg_nodes_begin)(const void *self, void *iter)
  71 {
  72         const be_ifg_t *ifg = self;
  73         return ifg->impl->nodes_begin(self, iter);
  74 }
  75
  76 ir_node *(be_ifg_nodes_next)(const void *self, void *iter)
  77 {
  78         const be_ifg_t *ifg = self;
  79         return ifg->impl->nodes_next(self, iter);
  80 }
  81
  82 void (be_ifg_nodes_break)(const void *self, void *iter)
  83 {
  84         const be_ifg_t *ifg = self;
  85         ifg->impl->nodes_break(self, iter);
  86 }
  87
  88 int (be_ifg_degree)(const void *self, const ir_node *irn)
  89 {
  90         const be_ifg_t *ifg = self;
  91         return ifg->impl->degree(self, irn);
  92 }
  93
  94
  95 int be_ifg_is_simplicial(const be_ifg_t *ifg, const ir_node *irn)
  96 {
  97         int degree = be_ifg_degree(ifg, irn);
  98         void *iter = be_ifg_neighbours_iter_alloca(ifg);
  99
 100         ir_node **neighbours = malloc(degree * sizeof(neighbours[0]));
 101
 102         ir_node *curr;
 103         int i, j;
 104
 105         be_ifg_foreach_neighbour(ifg, iter, irn, curr)
 106                 neighbours[i++] = curr;
 107
 108         for(i = 0; i < degree; ++i) {
 109                 for(j = 0; j < i; ++j)
 110                         if(!be_ifg_connected(ifg, neighbours[i], neighbours[j])) {
 111                                 free(neighbours);
 112                                 return 0;
 113                         }
 114         }
 115
 116
 117         free(neighbours);
 118         return 1;
 119 }
 120
 121 void be_ifg_check(const be_ifg_t *ifg)
 122 {
 123         void *iter1 = be_ifg_nodes_iter_alloca(ifg);
 124         void *iter2 = be_ifg_neighbours_iter_alloca(ifg);
 125
 126         ir_node *n, *m;
 127
 128         /* Check, if all neighbours are indeed connected to the node. */
 129         be_ifg_foreach_node(ifg, iter1, n) {
 130                 be_ifg_foreach_neighbour(ifg, iter2, n, m)
 131                         if(!be_ifg_connected(ifg, n, m))
 132                                 ir_fprintf(stderr, "%+F is a neighbour of %+F but they are not connected!\n", n, m);
 133         }
 134 }