From 2822b67ee0e55acbdc420a9dc9a29d7e2b3f4723 Mon Sep 17 00:00:00 2001 From: Sebastian Hack Date: Thu, 22 Dec 2005 12:43:35 +0000 Subject: [PATCH] Changes API a little bit :-) --- ir/be/beifg.c | 26 ++++++++++++++++---------- ir/be/beifg.h | 25 +++++++++++++++---------- ir/be/beifg_std.c | 43 ++++++++++++++++++++++++++++++++++--------- ir/be/beifg_t.h | 8 ++++++-- 4 files changed, 71 insertions(+), 31 deletions(-) diff --git a/ir/be/beifg.c b/ir/be/beifg.c index d59302c42..4e569abae 100644 --- a/ir/be/beifg.c +++ b/ir/be/beifg.c @@ -25,12 +25,6 @@ #include "irprintf.h" #include "beifg_t.h" -size_t (be_ifg_iter_size)(const void *self) -{ - const be_ifg_t *ifg = self; - return ifg->impl->iter_size; -} - void (be_ifg_free)(void *self) { be_ifg_t *ifg = self; @@ -55,6 +49,12 @@ ir_node *(be_ifg_neighbours_next)(const void *self, void *iter) return ifg->impl->neighbours_next(self, iter); } +void (be_ifg_neighbours_break)(const void *self, void *iter) +{ + const be_ifg_t *ifg = self; + ifg->impl->neighbours_break(self, iter); +} + ir_node *(be_ifg_nodes_begin)(const void *self, void *iter) { const be_ifg_t *ifg = self; @@ -67,6 +67,12 @@ ir_node *(be_ifg_nodes_next)(const void *self, void *iter) return ifg->impl->nodes_next(self, iter); } +void (be_ifg_nodes_break)(const void *self, void *iter) +{ + const be_ifg_t *ifg = self; + ifg->impl->nodes_break(self, iter); +} + int (be_ifg_degree)(const void *self, const ir_node *irn) { const be_ifg_t *ifg = self; @@ -77,7 +83,7 @@ int (be_ifg_degree)(const void *self, const ir_node *irn) int be_ifg_is_simplicial(const be_ifg_t *ifg, const ir_node *irn) { int degree = be_ifg_degree(ifg, irn); - void *iter = be_ifg_iter_alloca(ifg); + void *iter = be_ifg_neighbours_iter_alloca(ifg); ir_node **neighbours = malloc(degree * sizeof(neighbours[0])); @@ -100,10 +106,10 @@ int be_ifg_is_simplicial(const be_ifg_t *ifg, const ir_node *irn) return 1; } -void be_fg_check(const be_ifg_t *ifg) +void be_ifg_check(const be_ifg_t *ifg) { - void *iter1 = be_ifg_iter_alloca(ifg); - void *iter2 = be_ifg_iter_alloca(ifg); + void *iter1 = be_ifg_neighbours_iter_alloca(ifg); + void *iter2 = be_ifg_neighbours_iter_alloca(ifg); ir_node *n, *m; diff --git a/ir/be/beifg.h b/ir/be/beifg.h index 64b77a406..18910b679 100644 --- a/ir/be/beifg.h +++ b/ir/be/beifg.h @@ -15,16 +15,21 @@ typedef struct _be_ifg_impl_t be_ifg_impl_t; typedef struct _be_ifg_t be_ifg_t; -#define be_ifg_iter_alloca(self) (alloca(be_ifg_iter_size(self))) - -size_t be_ifg_iter_size(const void *self); -void be_ifg_free(void *self); -int be_ifg_connected(const void *self, const ir_node *a, const ir_node *b); -ir_node *be_ifg_neighbours_begin(const void *self, void *iter, const ir_node *irn); -ir_node *be_ifg_neighbours_next(const void *self, void *iter); -ir_node *be_ifg_nodes_begin(const void *self, void *iter); -ir_node *be_ifg_nodes_next(const void *self, void *iter); -int be_ifg_degree(const void *self, const ir_node *irn); +#define be_ifg_nodes_iter_size(self) ((self)->impl->nodes_iter_size) +#define be_ifg_neighbours_iter_size(self) ((self)->impl->neighbours_iter_size) + +#define be_ifg_neighbours_iter_alloca(self) (alloca(be_ifg_neighbours_iter_size(self))) +#define be_ifg_nodes_iter_alloca(self) (alloca(be_ifg_nodes_iter_size(self))) + +void (be_ifg_free)(void *self); +int (be_ifg_connected)(const void *self, const ir_node *a, const ir_node *b); +ir_node *(be_ifg_neighbours_begin)(const void *self, void *iter, const ir_node *irn); +ir_node *(be_ifg_neighbours_next)(const void *self, void *iter); +void (be_ifg_neighbours_break)(const void *self, void *iter); +ir_node *(be_ifg_nodes_begin)(const void *self, void *iter); +ir_node *(be_ifg_nodes_next)(const void *self, void *iter); +void (be_ifg_nodes_break)(const void *self, void *iter); +int (be_ifg_degree)(const void *self, const ir_node *irn); #define be_ifg_foreach_neighbour(self, iter, irn, pos) \ for(pos = be_ifg_neighbours_begin(self, iter, irn); (pos); pos = be_ifg_neighbours_next(self, iter)) diff --git a/ir/be/beifg_std.c b/ir/be/beifg_std.c index 59860a67a..40deccc39 100644 --- a/ir/be/beifg_std.c +++ b/ir/be/beifg_std.c @@ -6,6 +6,7 @@ * Copyright (C) 2005 Universitaet Karlsruhe * Released under the GPL */ + #ifdef HAVE_CONFIG_H #include "config.h" #endif @@ -77,6 +78,14 @@ static void find_nodes(const void *self, void *iter) { it->nodes = obstack_finish(&it->obst); } +static INLINE void node_break(nodes_iter_t *it, int force) +{ + if((it->curr >= it->n || force) && it->nodes) { + obstack_free(&it->obst, NULL); + it->nodes = NULL; + } +} + static ir_node *get_next_node(void *iter) { nodes_iter_t *it = iter; @@ -85,10 +94,7 @@ static ir_node *get_next_node(void *iter) if(it->curr < it->n) res = it->nodes[it->curr++]; - if(it->curr >= it-> n && it->nodes) { - obstack_free(&it->obst, NULL); - it->nodes = NULL; - } + node_break(it, 0); return res; } @@ -104,6 +110,11 @@ static ir_node *ifg_std_nodes_next(const void *self, void *iter) return get_next_node(iter); } +static void ifg_std_nodes_end(const void *self, void *iter) +{ + node_break(iter, 1); +} + typedef struct _adj_iter_t { const be_chordal_env_t *env; const ir_node *irn; @@ -167,16 +178,21 @@ static void find_neighbours(const ifg_std_t *ifg, adj_iter_t *it, const ir_node it->neighbours = obstack_finish(&it->obst); } +static INLINE void neighbours_break(adj_iter_t *it, int force) +{ + if((it->curr >= it->degree || force) && it->neighbours) { + obstack_free(&it->obst, NULL); + it->neighbours = NULL; + } +} + static ir_node *get_next_neighbour(adj_iter_t *it) { ir_node *res = NULL; if(it->curr < it->degree) res = it->neighbours[it->curr++]; - if(it->curr >= it->degree && it->neighbours) { - obstack_free(&it->obst, NULL); - it->neighbours = NULL; - } + neighbours_break(it, 0); return res; } @@ -192,6 +208,11 @@ static ir_node *ifg_std_neighbours_next(const void *self, void *iter) return get_next_neighbour(iter); } +static void ifg_std_neighbours_end(const void *self, void *iter) +{ + neighbours_break(iter, 1); +} + static int ifg_std_degree(const void *self, const ir_node *irn) { adj_iter_t it; @@ -200,13 +221,17 @@ static int ifg_std_degree(const void *self, const ir_node *irn) } static const be_ifg_impl_t ifg_std_impl = { - MAX(sizeof(adj_iter_t), sizeof(nodes_iter_t)), + sizeof(nodes_iter_t), + sizeof(adj_iter_t), + ifg_std_free, ifg_std_connected, ifg_std_neighbours_begin, ifg_std_neighbours_next, + ifg_std_neighbours_break, ifg_std_nodes_begin, ifg_std_nodes_next, + ifg_std_nodes_break, ifg_std_degree }; diff --git a/ir/be/beifg_t.h b/ir/be/beifg_t.h index 5e3f08587..2496105bd 100644 --- a/ir/be/beifg_t.h +++ b/ir/be/beifg_t.h @@ -11,16 +11,19 @@ #include "beifg.h" struct _be_ifg_impl_t { - size_t iter_size; + size_t nodes_iter_size; + size_t neighbours_iter_size; void (*free)(void *self); int (*connected)(const void *self, const ir_node *a, const ir_node *b); ir_node *(*neighbours_begin)(const void *self, void *iter, const ir_node *irn); ir_node *(*neighbours_next)(const void *self, void *iter); + void (*neighbours_break)(const void *self, void *iter); ir_node *(*nodes_begin)(const void *self, void *iter); ir_node *(*nodes_next)(const void *self, void *iter); + void (*nodes_break)(const void *self, void *iter); int (*degree)(const void *self, const ir_node *irn); }; @@ -31,13 +34,14 @@ struct _be_ifg_t { #ifdef _BE_IFG_USE_MACROS -#define be_ifg_iter_size(self) ((self)->impl->iter_size) #define be_ifg_free(self) ((self)->impl->free(self)) #define be_ifg_connected(self,a,b) ((self)->impl->connected(self, a, b)) #define be_ifg_neighbours_begin(self, iter, irn) ((self)->impl->neighbours_begin(self, iter, irn)) #define be_ifg_neighbours_next(self, iter) ((self)->impl->neighbours_next(self, iter)) +#define be_ifg_neighbours_break(self, iter) ((self)->impl->neighbours_break(self, iter)) #define be_ifg_nodes_begin(self, iter) ((self)->impl->nodes_begin(self, iter)) #define be_ifg_nodes_next(self, iter) ((self)->impl->nodes_next(self, iter)) +#define be_ifg_nodes_break(self, iter) ((self)->impl->nodes_break(self, iter)) #define be_ifg_degree(self,irn) ((self)->impl->degree(self, irn)) #endif -- 2.20.1