From 3eced231d086db25ba65f7265950915671fe6467 Mon Sep 17 00:00:00 2001 From: Matthias Braun Date: Mon, 26 Mar 2007 08:45:35 +0000 Subject: [PATCH] fix warning, add a Block_block_visited function, don't compile edge verification code when DEBUG_libfirm is set [r8733] --- ir/ir/iredges.c | 5 +- ir/ir/irgraph.h | 6 +-- ir/ir/irnode_t.h | 11 ++++- ir/ir/irnodeset.c | 45 ++++++++++++++++++ ir/ir/irnodeset.h | 118 ++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 177 insertions(+), 8 deletions(-) create mode 100644 ir/ir/irnodeset.c create mode 100644 ir/ir/irnodeset.h diff --git a/ir/ir/iredges.c b/ir/ir/iredges.c index f227a61e1..fd46b02e7 100644 --- a/ir/ir/iredges.c +++ b/ir/ir/iredges.c @@ -370,6 +370,7 @@ void edges_notify_edge_kind(ir_node *src, int pos, ir_node *tgt, edge_change_cnt(tgt, kind, +1); } /* else */ +#ifndef DEBUG_libfirm /* verify list heads */ if (edges_dbg) { if (tgt) @@ -377,6 +378,7 @@ void edges_notify_edge_kind(ir_node *src, int pos, ir_node *tgt, if (old_tgt) vrfy_list_head(old_tgt, kind); } +#endif DBG((dbg, LEVEL_5, "announce out edge: %+F %d-> %+F(%+F): %s\n", src, pos, tgt, old_tgt, msg)); } @@ -740,9 +742,6 @@ int edges_verify(ir_graph *irg) { struct build_walker w; int problem_found = 0; - if (! edges_dbg) - return 0; - /* verify normal edges only */ problem_found = edges_verify_kind(irg, EDGE_KIND_NORMAL); diff --git a/ir/ir/irgraph.h b/ir/ir/irgraph.h index 8655b060b..c3e253dff 100644 --- a/ir/ir/irgraph.h +++ b/ir/ir/irgraph.h @@ -496,13 +496,13 @@ int using_irn_link(const ir_graph *irg); #else static INLINE void set_using_block_visited(ir_graph *irg) { (void) irg; } static INLINE void clear_using_block_visited(ir_graph *irg) { (void) irg; } -static int using_block_visited(const ir_graph *irg) { (void) irg; return 0; } +static INLINE int using_block_visited(const ir_graph *irg) { (void) irg; return 0; } static INLINE void set_using_visited(ir_graph *irg) { (void) irg; } static INLINE void clear_using_visited(ir_graph *irg) { (void) irg; } -static int using_visited(const ir_graph *irg) { (void) irg; return 0; } +static INLINE int using_visited(const ir_graph *irg) { (void) irg; return 0; } static INLINE void set_using_irn_link(ir_graph *irg) { (void) irg; } static INLINE void clear_using_irn_link(ir_graph *irg) { (void) irg; } -static int using_irn_link(const ir_graph *irg) { (void) irg; return 0; } +static INLINE int using_irn_link(const ir_graph *irg) { (void) irg; return 0; } #endif /** move Proj nodes into the same block as its predecessors */ diff --git a/ir/ir/irnode_t.h b/ir/ir/irnode_t.h index 5eb12b79b..e6605cbaa 100644 --- a/ir/ir/irnode_t.h +++ b/ir/ir/irnode_t.h @@ -827,7 +827,7 @@ _get_Block_cfgpred_block(ir_node *node, int pos) { } static INLINE unsigned long -_get_Block_block_visited(ir_node *node) { +_get_Block_block_visited(const ir_node *node) { assert(node->op == op_Block); return node->attr.block.block_visited; } @@ -846,11 +846,17 @@ _mark_Block_block_visited(ir_node *node) { } static INLINE int -_Block_not_block_visited(ir_node *node) { +_Block_not_block_visited(const ir_node *node) { assert(node->op == op_Block); return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph)); } +static INLINE int +_Block_block_visited(const ir_node *node) { + assert(node->op == op_Block); + return (node->attr.block.block_visited >= get_irg_block_visited(current_ir_graph)); +} + static INLINE ir_node * _set_Block_dead(ir_node *block) { assert(_get_irn_op(block) == op_Block); @@ -1010,6 +1016,7 @@ static INLINE unsigned _get_irn_idx(const ir_node *node) { #define set_Block_block_visited(node, visit) _set_Block_block_visited(node, visit) #define mark_Block_block_visited(node) _mark_Block_block_visited(node) #define Block_not_block_visited(node) _Block_not_block_visited(node) +#define Block_block_visited(node) _Block_block_visited(node) #define set_Block_dead(block) _set_Block_dead(block) #define is_Block_dead(block) _is_Block_dead(block) #define get_Const_tarval(node) _get_Const_tarval(node) diff --git a/ir/ir/irnodeset.c b/ir/ir/irnodeset.c new file mode 100644 index 000000000..7ab40f983 --- /dev/null +++ b/ir/ir/irnodeset.c @@ -0,0 +1,45 @@ +/** + * @file + * @author Matthias Braun + * @date 30.03.2007 + * @brief A nodeset. This should be prefered over a simple pset, because it + tries to guarantee deterministic behavior. + * @version $Id$ + */ +#include + +#include "irnodeset.h" +#include "hashptr.h" + +#define DO_REHASH +#define ID_HASH +#define HashSet ir_nodeset_t +#define HashSetIterator ir_nodeset_iterator_t +#define ValueType ir_node* +#define NullValue NULL +#define DeletedValue ((ir_node*)-1) +#ifdef FIRM_debug +#define Hash(this,value) (value)->node_nr +#else +#define Hash(this,value) HASH_PTR(value) +#endif +#define KeysEqual(this,key1,key2) (key1) == (key2) +#define SetRangeEmpty(ptr,size) memset(ptr, 0, (size) * sizeof((ptr)[0])) + +#define hashset_init ir_nodeset_init +#define hashset_init_size ir_nodeset_init_size +#define hashset_destroy ir_nodeset_destroy +#define hashset_insert ir_nodeset_insert +#define hashset_remove ir_nodeset_remove +#define hashset_find _ir_nodeset_find +#define hashset_size ir_nodeset_size +#define hashset_iterator_init ir_nodeset_iterator_init +#define hashset_iterator_next ir_nodeset_iterator_next +#define hashset_remove_iterator ir_nodeset_remove_iterator + +#include "hashset.c" + +int ir_nodeset_contains(const ir_nodeset_t *this, const ir_node *node) +{ + return _ir_nodeset_find(this, node) != NULL; +} diff --git a/ir/ir/irnodeset.h b/ir/ir/irnodeset.h new file mode 100644 index 000000000..e20e99d4f --- /dev/null +++ b/ir/ir/irnodeset.h @@ -0,0 +1,118 @@ +/** + * @file + * @author Matthias Braun + * @date 30.03.2007 + * @brief A nodeset. This should be prefered over a simple pset, because it + * tries to guarantee deterministic behavior. (and is faster) + * @version $Id$ + */ +#ifndef _FIRM_IRNODESET_H_ +#define _FIRM_IRNODESET_H_ + +#include "irnode.h" + +#define HashSet ir_nodeset_t +#define HashSetIterator ir_nodeset_iterator_t +#define ValueType ir_node* +#define DO_REHASH +#include "hashset.h" +#undef DO_REHASH +#undef ValueType +#undef HashSetIterator +#undef HashSet + +/** + * Initializes a nodeset + * + * @param nodeset Pointer to allocated space for the nodeset + */ +void ir_nodeset_init(ir_nodeset_t *nodeset); + +/** + * Initializes a nodeset + * + * @param nodeset Pointer to allocated space for the nodeset + * @param expected_elements Number of elements expected in the nodeset (rougly) + */ +void ir_nodeset_init_size(ir_nodeset_t *nodeset, size_t expected_elements); + +/** + * Destroys a nodeset and frees the memory allocated for hashtable. The memory of + * the nodeset itself is not freed. + * + * @param nodeset Pointer to the nodeset + */ +void ir_nodeset_destroy(ir_nodeset_t *nodeset); + +/** + * Inserts a node into a nodeset. + * + * @param nodeset Pointer to the nodeset + * @param node node to insert into the nodeset + * @returns 1 if the element has been inserted, + * 0 if it was already there + */ +int ir_nodeset_insert(ir_nodeset_t *nodeset, ir_node *node); + +/** + * Removes a node from a nodeset. Does nothing if the nodeset doesn't contain + * the node. + * + * @param nodeset Pointer to the nodeset + * @param node Node to remove from the nodeset + */ +void ir_nodeset_remove(ir_nodeset_t *nodeset, const ir_node *node); + +/** + * Tests whether a nodeset contains a specific node + * + * @param nodeset Pointer to the nodeset + * @param node The pointer to find + * @returns 1 if nodeset contains the node, 0 else + */ +int ir_nodeset_contains(const ir_nodeset_t *nodeset, const ir_node *node); + +/** + * Returns the number of pointers contained in the nodeset + * + * @param nodeset Pointer to the nodeset + * @returns Number of pointers contained in the nodeset + */ +size_t ir_nodeset_size(const ir_nodeset_t *nodeset); + +/** + * Initializes a nodeset iterator. Sets the iterator before the first element in + * the nodeset. + * + * @param iterator Pointer to already allocated iterator memory + * @param nodeset Pointer to the nodeset + */ +void ir_nodeset_iterator_init(ir_nodeset_iterator_t *iterator, + const ir_nodeset_t *nodeset); + +/** + * Advances the iterator and returns the current element or NULL if all elements + * in the nodeset have been processed. + * @attention It is not allowed to use nodeset_insert or nodeset_remove while + * iterating over a nodeset. + * + * @param iterator Pointer to the nodeset iterator. + * @returns Next element in the nodeset or NULL + */ +ir_node *ir_nodeset_iterator_next(ir_nodeset_iterator_t *iterator); + +/** + * Removes the element the iterator currently points to + * + * @param nodeset Pointer to the nodeset + * @param iterator Pointer to the nodeset iterator. + */ +void ir_nodeset_remove_iterator(ir_nodeset_t *nodeset, + const ir_nodeset_iterator_t *iterator); + +#define foreach_ir_nodeset(nodeset, irn, iter) \ + for(ir_nodeset_iterator_init(&iter, nodeset), \ + irn = ir_nodeset_iterator_next(&iter); \ + irn != NULL; irn = ir_nodeset_iterator_next(&iter)) + +#endif -- 2.20.1