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_iter_size)(const void *self)
  29 {
  30         const be_ifg_t *ifg = self;
  31         return ifg->impl->iter_size;
  32 }
  33
  34 void (be_ifg_free)(void *self)
  35 {
  36         be_ifg_t *ifg = self;
  37         ifg->impl->free(self);
  38 }
  39
  40 int (be_ifg_connected)(const void *self, const ir_node *a, const ir_node *b)
  41 {
  42         const be_ifg_t *ifg = self;
  43         return ifg->impl->connected(self, a, b);
  44 }
  45
  46 ir_node *(be_ifg_neighbours_begin)(const void *self, void *iter, const ir_node *irn)
  47 {
  48         const be_ifg_t *ifg = self;
  49         return ifg->impl->neighbours_begin(self, iter, irn);
  50 }
  51
  52 ir_node *(be_ifg_neighbours_next)(const void *self, void *iter)
  53 {
  54         const be_ifg_t *ifg = self;
  55         return ifg->impl->neighbours_next(self, iter);
  56 }
  57
  58 ir_node *(be_ifg_nodes_begin)(const void *self, void *iter)
  59 {
  60         const be_ifg_t *ifg = self;
  61         return ifg->impl->nodes_begin(self, iter);
  62 }
  63
  64 ir_node *(be_ifg_nodes_next)(const void *self, void *iter)
  65 {
  66         const be_ifg_t *ifg = self;
  67         return ifg->impl->nodes_next(self, iter);
  68 }
  69
  70 int (be_ifg_degree)(const void *self, const ir_node *irn)
  71 {
  72         const be_ifg_t *ifg = self;
  73         return ifg->impl->degree(self, irn);
  74 }
  75
  76
  77 int be_ifg_is_simplicial(const be_ifg_t *ifg, const ir_node *irn)
  78 {
  79         int degree = be_ifg_degree(ifg, irn);
  80         void *iter = be_ifg_iter_alloca(ifg);
  81
  82         ir_node **neighbours = malloc(degree * sizeof(neighbours[0]));
  83
  84         ir_node *curr;
  85         int i, j;
  86
  87         be_ifg_foreach_neighbour(ifg, iter, irn, curr)
  88                 neighbours[i++] = curr;
  89
  90         for(i = 0; i < degree; ++i) {
  91                 for(j = 0; j < i; ++j)
  92                         if(!be_ifg_connected(ifg, neighbours[i], neighbours[j])) {
  93                                 free(neighbours);
  94                                 return 0;
  95                         }
  96         }
  97
  98
  99         free(neighbours);
 100         return 1;
 101 }
 102
 103 void be_fg_check(const be_ifg_t *ifg)
 104 {
 105         void *iter1 = be_ifg_iter_alloca(ifg);
 106         void *iter2 = be_ifg_iter_alloca(ifg);
 107
 108         ir_node *n, *m;
 109
 110         /* Check, if all neighbours are indeed connected to the node. */
 111         be_ifg_foreach_node(ifg, iter1, n) {
 112                 be_ifg_foreach_neighbour(ifg, iter2, n, m)
 113                         if(!be_ifg_connected(ifg, n, m))
 114                                 ir_fprintf(stderr, "%+F is a neighbour of %+F but they are not connected!\n", n, m);
 115         }
 116 }