/*
- * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
*
* This file is part of libFirm.
*
* This are out-edges (also called def-use edges) that are dynamically
* updated as the graph changes.
*/
-#ifdef HAVE_CONFIG_H
#include "config.h"
-#endif
#include "irnode_t.h"
#include "iropt_t.h"
#include "irgwalk.h"
#include "irdump_t.h"
#include "irprintf.h"
-#include "irhooks.h"
#include "debug.h"
#include "set.h"
#include "bitset.h"
-#include "xmalloc.h"
+#include "error.h"
+
+#include "iredgeset.h"
+#include "hashptr.h"
+
+#define DO_REHASH
+#define SCALAR_RETURN
+#define HashSet ir_edgeset_t
+#define HashSetIterator ir_edgeset_iterator_t
+#define ValueType ir_edge_t*
+#define NullValue NULL
+#define DeletedValue ((ir_edge_t*)-1)
+#define Hash(this,key) (HASH_PTR(key->src) ^ (key->pos * 40013))
+#define KeysEqual(this,key1,key2) ((key1->src) == (key2->src) && (key1->pos == key2->pos))
+#define SetRangeEmpty(ptr,size) memset(ptr, 0, (size) * sizeof((ptr)[0]))
+
+#define hashset_init ir_edgeset_init
+#define hashset_init_size ir_edgeset_init_size
+#define hashset_destroy ir_edgeset_destroy
+#define hashset_insert ir_edgeset_insert
+#define hashset_remove ir_edgeset_remove
+#define hashset_find ir_edgeset_find
+#define hashset_size ir_edgeset_size
+#define hashset_iterator_init ir_edgeset_iterator_init
+#define hashset_iterator_next ir_edgeset_iterator_next
+#define hashset_remove_iterator ir_edgeset_remove_iterator
+
+#include "hashset.c"
/**
* A function that allows for setting an edge.
static long last_edge_num = -1;
#endif
-static INLINE long edge_get_id(const ir_edge_t *e) {
+static inline long edge_get_id(const ir_edge_t *e) {
#ifdef DEBUG_libfirm
return e->edge_nr;
#else /* DEBUG_libfirm */
* Caution: Using wrong values here can destroy other users private data!
*/
void edges_reset_private_data(ir_graph *irg, int offset, size_t size) {
- irg_edge_info_t *info = _get_irg_edge_info(irg, EDGE_KIND_NORMAL);
- ir_edge_t *edge;
+ irg_edge_info_t *info = _get_irg_edge_info(irg, EDGE_KIND_NORMAL);
+ ir_edge_t *edge;
+ ir_edgeset_iterator_t iter;
- foreach_set(info->edges, edge) {
+ foreach_ir_edgeset(&info->edges, edge, iter) {
memset(edge + sizeof(*edge) + offset, 0, size);
}
}
#define get_irn_out_list_head(irn) (&get_irn_out_info(irn)->outs)
-/**
- * Compare two edges.
- */
-static int edge_cmp(const void *p1, const void *p2, size_t len) {
- const ir_edge_t *e1 = p1;
- const ir_edge_t *e2 = p2;
- (void) len;
-
- if(e1->src != e2->src)
- return 1;
- if(e1->pos != e1->pos)
- return 1;
-
- return 0;
-}
-
#define edge_hash(edge) (TIMES37((edge)->pos) + HASH_PTR((edge)->src))
/**
void edges_init_graph_kind(ir_graph *irg, ir_edge_kind_t kind) {
if (edges_activated_kind(irg, kind)) {
irg_edge_info_t *info = _get_irg_edge_info(irg, kind);
- int amount = 2048;
+ size_t amount = irg->estimated_node_count * 2;
edges_used = 1;
- if(info->edges) {
- amount = set_count(info->edges);
- del_set(info->edges);
+ if(info->allocated) {
+ amount = ir_edgeset_size(&info->edges);
+ ir_edgeset_destroy(&info->edges);
+ obstack_free(&info->edges_obst, NULL);
}
- info->edges = new_set(edge_cmp, amount);
+ obstack_init(&info->edges_obst);
+ INIT_LIST_HEAD(&info->free_edges);
+ ir_edgeset_init_size(&info->edges, amount);
+ info->allocated = 1;
}
}
key.src = (ir_node *)src;
key.pos = pos;
- return set_find(info->edges, &key, EDGE_SIZE, edge_hash(&key));
+
+ return ir_edgeset_find(&info->edges, &key);
}
return NULL;
* @param tgt the edge target
* @param kind the kind of the edge
*/
-static INLINE void edge_change_cnt(ir_node *tgt, ir_edge_kind_t kind, int ofs) {
+static inline void edge_change_cnt(ir_node *tgt, ir_edge_kind_t kind, int ofs) {
irn_edge_info_t *info = _get_irn_edge_info(tgt, kind);
info->out_count += ofs;
* Verify the edge list of a node, ie. ensure it's a loop:
* head -> e_1 -> ... -> e_n -> head
*/
-static INLINE void vrfy_list_head(ir_node *irn, ir_edge_kind_t kind) {
+static inline void vrfy_list_head(ir_node *irn, ir_edge_kind_t kind) {
int err = 0;
int num = 0;
pset *lh_set = pset_new_ptr(16);
ir_node *old_tgt, ir_edge_kind_t kind,
ir_graph *irg)
{
- const char *msg = "";
+ const char *msg = "";
irg_edge_info_t *info;
- set *edges;
- ir_edge_t *templ;
- ir_edge_t *edge;
+ ir_edgeset_t *edges;
+ ir_edge_t templ;
+ ir_edge_t *edge;
assert(edges_activated_kind(irg, kind));
return;
info = _get_irg_edge_info(irg, kind);
- edges = info->edges;
- templ = alloca(EDGE_SIZE);
+ edges = &info->edges;
/* Initialize the edge template to search in the set. */
- memset(templ, 0, EDGE_SIZE);
- templ->src = src;
- templ->pos = pos;
- templ->invalid = 0;
- templ->present = 0;
- templ->kind = kind;
- DEBUG_ONLY(templ->src_nr = get_irn_node_nr(src));
+ templ.src = src;
+ templ.pos = pos;
/*
* If the target is NULL, the edge shall be deleted.
*/
if (tgt == NULL) {
/* search the edge in the set. */
- edge = set_find(edges, templ, EDGE_SIZE, edge_hash(templ));
+ edge = ir_edgeset_find(edges, &templ);
/* mark the edge invalid if it was found */
if (edge) {
msg = "deleting";
list_del(&edge->list);
+ ir_edgeset_remove(edges, edge);
+ list_add(&edge->list, &info->free_edges);
edge->invalid = 1;
edge->pos = -2;
edge->src = NULL;
edge->edge_nr = -1;
#endif /* DEBUG_libfirm */
edge_change_cnt(old_tgt, kind, -1);
- }
-
- /* If the edge was not found issue a warning on the debug stream */
- else {
+ } else {
+ /* If the edge was not found issue a warning on the debug stream */
msg = "edge to delete not found!\n";
}
- } /* if */
-
- /*
- * The target is not NULL and the old target differs
- * from the new target, the edge shall be moved (if the
- * old target was != NULL) or added (if the old target was
- * NULL).
- */
- else {
+ } else {
+ /*
+ * The target is not NULL and the old target differs
+ * from the new target, the edge shall be moved (if the
+ * old target was != NULL) or added (if the old target was
+ * NULL).
+ */
struct list_head *head = _get_irn_outs_head(tgt, kind);
assert(head->next && head->prev &&
/* If the old target is not null, the edge is moved. */
if (old_tgt) {
- edge = set_find(edges, templ, EDGE_SIZE, edge_hash(templ));
+ edge = ir_edgeset_find(edges, &templ);
assert(edge && "edge to redirect not found!");
assert(! edge->invalid && "Invalid edge encountered");
list_move(&edge->list, head);
edge_change_cnt(old_tgt, kind, -1);
- }
-
- /* The old target was null, thus, the edge is newly created. */
- else {
- edge = set_insert(edges, templ, EDGE_SIZE, edge_hash(templ));
-
- assert(! edge->invalid && "Freshly inserted edge is invalid?!?");
- assert(edge->list.next == NULL && edge->list.prev == NULL &&
- "New edge must not have list head initialized");
+ } else {
+ /* The old target was NULL, thus, the edge is newly created. */
+ ir_edge_t *new_edge;
+ ir_edge_t *edge;
+
+ if (list_empty(&info->free_edges)) {
+ edge = obstack_alloc(&info->edges_obst, EDGE_SIZE);
+ } else {
+ edge = list_entry(info->free_edges.next, ir_edge_t, list);
+ list_del(&edge->list);
+ }
+
+ edge->src = src;
+ edge->pos = pos;
+ edge->invalid = 0;
+ edge->present = 0;
+ edge->kind = kind;
+ edge->list.next = NULL;
+ edge->list.prev = NULL;
+ DEBUG_ONLY(edge->src_nr = get_irn_node_nr(src));
+
+ new_edge = ir_edgeset_insert(edges, edge);
+ if (new_edge != edge) {
+ panic("new edge exists already");
+ }
msg = "adding";
list_add(&edge->list, head);
-#ifdef DEBUG_libfirm
- edge->edge_nr = ++last_edge_num;
-#endif /* DEBUG_libfirm */
+ DEBUG_ONLY(edge->edge_nr = ++last_edge_num);
}
edge_change_cnt(tgt, kind, +1);
ir_graph *irg = w->irg;
get_edge_src_n_func_t *get_n;
- if (! edges_activated_kind(irg, kind))
- return;
-
get_n = edge_kind_info[kind].get_n;
foreach_tgt(irn, i, n, kind) {
ir_node *pred = get_n(irn, i, kind);
static void init_lh_walker(ir_node *irn, void *data) {
struct build_walker *w = data;
ir_edge_kind_t kind = w->kind;
- INIT_LIST_HEAD(_get_irn_outs_head(irn, kind));
+ list_head *head = _get_irn_outs_head(irn, kind);
+ INIT_LIST_HEAD(head);
+ _get_irn_edge_info(irn, kind)->out_count = 0;
+}
+
+/**
+ * Pre-Walker: initializes the list-heads and set the out-count
+ * of all nodes to 0.
+ *
+ * Additionally touches DEP nodes, as they might be DEAD.
+ * THIS IS UGLY, but I don't find a better way until we
+ *
+ * a) ensure that dead nodes are not used as input
+ * b) it might be sufficient to add those stupid NO_REG nodes
+ * to the anchor
+ */
+static void init_lh_walker_dep(ir_node *irn, void *data) {
+ struct build_walker *w = data;
+ ir_edge_kind_t kind = w->kind;
+ list_head *head = _get_irn_outs_head(irn, kind);
+ int i;
+
+ INIT_LIST_HEAD(head);
_get_irn_edge_info(irn, kind)->out_count = 0;
+
+ for (i = get_irn_deps(irn) - 1; i >= 0; --i) {
+ ir_node *dep = get_irn_dep(irn, i);
+
+ head = _get_irn_outs_head(dep, kind);
+
+ INIT_LIST_HEAD(head);
+ _get_irn_edge_info(dep, kind)->out_count = 0;
+ }
}
+typedef struct visitor_info_t {
+ irg_walk_func *visit;
+ void *data;
+} visitor_info_t;
+
/**
* Visitor: initializes the list-heads and set the out-count
* of all nodes to 0 of nodes that are not seen so far.
*/
static void visitor(ir_node *irn, void *data) {
- if (irn_not_visited(irn)) {
+ visitor_info_t *info = data;
+
+ if (!irn_visited(irn)) {
mark_irn_visited(irn);
- init_lh_walker(irn, data);
+ info->visit(irn, info->data);
}
}
void edges_activate_kind(ir_graph *irg, ir_edge_kind_t kind)
{
struct build_walker w;
- irg_edge_info_t *info = _get_irg_edge_info(irg, kind);
+ irg_edge_info_t *info = _get_irg_edge_info(irg, kind);
+ visitor_info_t visit;
w.irg = irg;
w.kind = kind;
+ visit.data = &w;
+
info->activated = 1;
edges_init_graph_kind(irg, kind);
- irg_walk_anchors(irg, init_lh_walker, build_edges_walker, &w);
- visit_all_identities(irg, visitor, &w);
+ if (kind == EDGE_KIND_DEP) {
+ irg_walk_anchors(irg, init_lh_walker_dep, NULL, &w);
+ /* Argh: Dep nodes might be dead, so we MUST visit identities first */
+ visit.visit = init_lh_walker_dep;
+ visit_all_identities(irg, visitor, &visit);
+ irg_walk_anchors(irg, NULL, build_edges_walker, &w);
+ } else {
+ irg_walk_anchors(irg, init_lh_walker, build_edges_walker, &w);
+ visit.visit = init_lh_walker;
+ visit_all_identities(irg, visitor, &visit);
+ }
}
void edges_deactivate_kind(ir_graph *irg, ir_edge_kind_t kind)
irg_edge_info_t *info = _get_irg_edge_info(irg, kind);
info->activated = 0;
- if (info->edges) {
- del_set(info->edges);
- info->edges = NULL;
+ if (info->allocated) {
+ obstack_free(&info->edges_obst, NULL);
+ ir_edgeset_destroy(&info->edges);
+ info->allocated = 0;
}
}
static void verify_set_presence(ir_node *irn, void *data)
{
struct build_walker *w = data;
- set *edges = _get_irg_edge_info(w->irg, w->kind)->edges;
+ ir_edgeset_t *edges = &_get_irg_edge_info(w->irg, w->kind)->edges;
int i, n;
foreach_tgt(irn, i, n, w->kind) {
templ.src = irn;
templ.pos = i;
- e = set_find(edges, &templ, EDGE_SIZE, edge_hash(&templ));
+ e = ir_edgeset_find(edges, &templ);
if(e != NULL) {
e->present = 1;
} else {
int edges_verify_kind(ir_graph *irg, ir_edge_kind_t kind)
{
struct build_walker w;
- set *edges = _get_irg_edge_info(irg, kind)->edges;
+ ir_edgeset_t *edges = &_get_irg_edge_info(irg, kind)->edges;
ir_edge_t *e;
+ ir_edgeset_iterator_t iter;
w.irg = irg;
w.kind = kind;
w.problem_found = 0;
/* Clear the present bit in all edges available. */
- for (e = set_first(edges); e; e = set_next(edges))
+ foreach_ir_edgeset(edges, e, iter) {
e->present = 0;
+ }
irg_walk_graph(irg, verify_set_presence, verify_list_presence, &w);
* These edges are superfluous and their presence in the
* edge set is wrong.
*/
- for (e = set_first(edges); e; e = set_next(edges)) {
+ foreach_ir_edgeset(edges, e, iter) {
if (! e->invalid && ! e->present && bitset_is_set(w.reachable, get_irn_idx(e->src))) {
w.problem_found = 1;
ir_fprintf(stderr, "Edge Verifier: edge(%ld) %+F,%d is superfluous\n", edge_get_id(e), e->src, e->pos);
void edges_activate(ir_graph *irg) {
edges_activate_kind(irg, EDGE_KIND_NORMAL);
edges_activate_kind(irg, EDGE_KIND_BLOCK);
+ if (get_irg_phase_state(irg) == phase_backend)
+ edges_activate_kind(irg, EDGE_KIND_DEP);
}
void edges_deactivate(ir_graph *irg) {
- edges_deactivate_kind(irg, EDGE_KIND_NORMAL);
+ if (get_irg_phase_state(irg) == phase_backend)
+ edges_deactivate_kind(irg, EDGE_KIND_DEP);
edges_deactivate_kind(irg, EDGE_KIND_BLOCK);
+ edges_deactivate_kind(irg, EDGE_KIND_NORMAL);
}
int edges_assure(ir_graph *irg) {
return activated;
}
+int edges_assure_kind(ir_graph *irg, ir_edge_kind_t kind) {
+ int activated = edges_activated_kind(irg, kind);
+
+ if (!activated)
+ edges_activate_kind(irg, kind);
+
+ return activated;
+}
+
void edges_node_deleted(ir_node *irn, ir_graph *irg) {
edges_node_deleted_kind(irn, EDGE_KIND_NORMAL, irg);
edges_node_deleted_kind(irn, EDGE_KIND_BLOCK, irg);
void *env) {
const ir_edge_t *edge, *next;
- if (Block_not_block_visited(bl)) {
+ if (!Block_block_visited(bl)) {
mark_Block_block_visited(bl);
if (pre)
}
}
-/* Walks only over Block nodes in the graph. Has it's own visited
- flag, so that it can be interleaved with the other walker. */
void irg_block_edges_walk(ir_node *node,
irg_walk_func *pre, irg_walk_func *post,
void *env) {
assert(edges_activated(current_ir_graph));
assert(is_Block(node));
+ ir_reserve_resources(current_ir_graph, IR_RESOURCE_BLOCK_VISITED);
+
inc_irg_block_visited(current_ir_graph);
irg_block_edges_walk2(node, pre, post, env);
+
+ ir_free_resources(current_ir_graph, IR_RESOURCE_BLOCK_VISITED);
}
projects / libfirm / blobdiff