From: Matthias Braun Date: Tue, 13 Dec 2011 23:25:31 +0000 (+0100) Subject: remove deprecated eset X-Git-Url: http://nsz.repo.hu/git/?a=commitdiff_plain;h=916caec9328586dd9922020233ae419aa29facea;p=libfirm remove deprecated eset Replace with equivalent pset_ptr stuff --- diff --git a/include/libfirm/adt/eset.h b/include/libfirm/adt/eset.h deleted file mode 100644 index 79b8e6cb0..000000000 --- a/include/libfirm/adt/eset.h +++ /dev/null @@ -1,85 +0,0 @@ -/* - * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved. - * - * This file is part of libFirm. - * - * This file may be distributed and/or modified under the terms of the - * GNU General Public License version 2 as published by the Free Software - * Foundation and appearing in the file LICENSE.GPL included in the - * packaging of this file. - * - * Licensees holding valid libFirm Professional Edition licenses may use - * this file in accordance with the libFirm Commercial License. - * Agreement provided with the Software. - * - * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE - * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE. - */ - -/** - * @file - * @brief a pointer hashset (WARNING: deprecated, use hashset_new.* - * instead) - * @author Hubert Schmid - * @date 09.06.2002 - * @deprecated - */ -#ifndef FIRM_ADT_ESET_H -#define FIRM_ADT_ESET_H - -#include - -#include "../begin.h" - -/** - * "eset" is a set of addresses. The addresses are used for element - * compare and hash calculation. - * The value "NULL" can not be stored, as it is used as internal sentinel. - */ -typedef struct eset eset; - -/** Creates a new empty set. */ -FIRM_API eset *eset_create(void); - -/** - * Creates a copy of the given set. Does NOT work if NULL is contained in source. */ -FIRM_API eset *eset_copy(eset *source); - -/** Deletes a set. */ -FIRM_API void eset_destroy(eset *s); - -/** Returns the number of elements in the set. */ -FIRM_API size_t eset_count(eset *s); - -/** Inserts an address into the set. */ -FIRM_API void eset_insert(eset *s, void *p); - -/** Checks, whether an address is element of a set. */ -FIRM_API int eset_contains(eset *s, void *p); - -/** - * Starts the iteration over a set and returns the first element or NULL - * if the set is empty. - * - * @note: It is NOT possible to add new elements while iterating through a set. - */ -FIRM_API void *eset_first(eset *s); - -/** - * Continues iteration through a set and returns the next element or NULL if the - * iteration is finished. - * - * @note: It is NOT possible to add new elements while iterating through a set. - */ -FIRM_API void *eset_next(eset *s); - -/** Inserts all elements of source into target (union). Does NOT work if NULL is contained in source. */ -FIRM_API void eset_insert_all(eset *target, eset *source); - -#define eset_foreach(eset, type, iter) \ - for ((iter) = (type)eset_first((eset)); (iter) != NULL; (iter) = (type)eset_next((eset))) - -#include "../end.h" - -#endif diff --git a/ir/adt/eset.c b/ir/adt/eset.c deleted file mode 100644 index 8614a91a0..000000000 --- a/ir/adt/eset.c +++ /dev/null @@ -1,111 +0,0 @@ -/* - * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved. - * - * This file is part of libFirm. - * - * This file may be distributed and/or modified under the terms of the - * GNU General Public License version 2 as published by the Free Software - * Foundation and appearing in the file LICENSE.GPL included in the - * packaging of this file. - * - * Licensees holding valid libFirm Professional Edition licenses may use - * this file in accordance with the libFirm Commercial License. - * Agreement provided with the Software. - * - * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE - * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE. - */ - -/** - * @file - * @brief A pointer hash-set (WARNING: deprecated!) - * @author Hubert Schmid - * @date 09.06.2002 - */ -#include "config.h" - -#include "eset.h" -#include "set.h" -#include "hashptr.h" - -struct eset { - int dummy; /* dummy entry */ -}; - - -#define INITIAL_SLOTS 64 - -static int pcmp(const void *p1, const void *p2, size_t size) -{ - const void **q1 = (const void **)p1; - const void **q2 = (const void **)p2; - (void) size; - - return *q1 != *q2; -} - - -eset * eset_create(void) -{ - return (eset *) new_set(pcmp, INITIAL_SLOTS); -} - - -eset * eset_copy(eset *source) -{ - eset * ret = eset_create(); - void * p; - for (p = eset_first(source); p; p = eset_next(source)) { - eset_insert(ret, p); - } - return ret; -} - - -void eset_destroy(eset *s) -{ - del_set((set *)s); -} - -/* Returns the number of elements in the set. */ -size_t eset_count(eset *s) -{ - return set_count((set *)s); -} - -void eset_insert(eset *s, void *p) -{ - if (!eset_contains(s, p)) { - set_insert((set *)s, &p, sizeof(p), hash_ptr(p)); - } -} - - -int eset_contains(eset *s, void *p) -{ - return set_find((set *)s, &p, sizeof(p), hash_ptr(p)) != NULL; -} - - -void * eset_first(eset *s) -{ - void * p = set_first((set *) s); - return p == NULL ? NULL : *((void **)p); -} - - -void * eset_next(eset *s) -{ - void *p = set_next((set *) s); - return p == NULL ? NULL : *((void **)p); -} - - -void eset_insert_all(eset *target, eset *source) -{ - void *p; - for (p = eset_first(source); p; p = eset_next(source)) { - eset_insert(target, p); - } -} diff --git a/ir/ana/cgana.c b/ir/ana/cgana.c index b6d6195d8..76c152cce 100644 --- a/ir/ana/cgana.c +++ b/ir/ana/cgana.c @@ -50,7 +50,6 @@ #include "dbginfo_t.h" #include "iropt_dbg.h" -#include "eset.h" #include "pmap.h" #include "array.h" #include "error.h" @@ -60,7 +59,7 @@ /* unambiguous address used as a mark. */ static void *MARK = &MARK; -static eset *entities = NULL; +static pset *entities = NULL; /*--------------------------------------------------------------------------*/ /* The analysis */ @@ -83,14 +82,14 @@ static eset *entities = NULL; * * @return Number of entities in set. */ -static size_t collect_impls(ir_entity *method, eset *set) +static size_t collect_impls(ir_entity *method, pset *set) { size_t i; size_t size = 0; if (get_entity_irg(method) != NULL) { /* has an implementation */ - eset_insert(set, method); + pset_insert_ptr(set, method); ++size; } @@ -110,7 +109,7 @@ static size_t collect_impls(ir_entity *method, eset *set) static ir_entity **get_impl_methods(ir_entity *method) { ir_entity **arr; - eset *set = eset_create(); + pset *set = pset_new_ptr_default(); size_t size; /* Collect all method entities that can be called here */ @@ -122,10 +121,11 @@ static ir_entity **get_impl_methods(ir_entity *method) } else { ir_entity * ent; arr = NEW_ARR_F(ir_entity *, size); - for (ent = (ir_entity*) eset_first(set); size > 0; ent = (ir_entity*) eset_next(set)) + foreach_pset(set, ir_entity*, ent) { arr[--size] = ent; + } } - eset_destroy(set); + del_pset(set); return arr; } @@ -166,12 +166,12 @@ static void sel_methods_walker(ir_node *node, void *env) if (is_Sel(node) && is_Method_type(get_entity_type(get_Sel_entity(node)))) { ir_entity *ent = get_SymConst_entity(get_atomic_ent_value(get_Sel_entity(node))); - if (!eset_contains(entities, ent)) { + if (!pset_find_ptr(entities, ent)) { /* Entity not yet handled. Find all (internal or external) * implemented methods that overwrites this entity. * This set is stored in the entity link. */ set_entity_link(ent, get_impl_methods(ent)); - eset_insert(entities, ent); + pset_insert_ptr(entities, ent); } /* -- As an add on we get an optimization that removes polymorphic calls. @@ -221,7 +221,7 @@ static void sel_methods_init(void) pmap *ldname_map = pmap_create(); /* Map entity names to entities: to replace SymConst(name) by SymConst(ent). */ assert(entities == NULL); - entities = eset_create(); + entities = pset_new_ptr_default(); for (i = 0, n = get_irp_n_irgs(); i < n; ++i) { ir_entity * ent = get_irg_entity(get_irp_irg(i)); /* only external visible methods are allowed to call by a SymConst_ptr_name */ @@ -291,9 +291,9 @@ static ir_entity * get_Sel_method(ir_node * sel, size_t pos) } /* forward */ -static void free_mark(ir_node * node, eset * set); +static void free_mark(ir_node *node, pset *set); -static void free_mark_proj(ir_node * node, long n, eset * set) +static void free_mark_proj(ir_node *node, long n, pset *set) { assert(get_irn_mode(node) == mode_T); if (get_irn_link(node) == MARK) { @@ -348,7 +348,7 @@ static void free_mark_proj(ir_node * node, long n, eset * set) * @param node the current visited node * @param set the set of all free methods */ -static void free_mark(ir_node *node, eset * set) +static void free_mark(ir_node *node, pset *set) { if (get_irn_link(node) == MARK) return; /* already visited */ @@ -361,7 +361,7 @@ static void free_mark(ir_node *node, eset * set) if (is_method_entity(ent)) { size_t i, n; for (i = 0, n = get_Sel_n_methods(node); i < n; ++i) { - eset_insert(set, get_Sel_method(node, i)); + pset_insert_ptr(set, get_Sel_method(node, i)); } } break; @@ -370,7 +370,7 @@ static void free_mark(ir_node *node, eset * set) if (get_SymConst_kind(node) == symconst_addr_ent) { ir_entity *ent = get_SymConst_entity(node); if (is_method_entity(ent)) { - eset_insert(set, ent); + pset_insert_ptr(set, ent); } } break; @@ -397,7 +397,7 @@ static void free_mark(ir_node *node, eset * set) */ static void free_ana_walker(ir_node *node, void *env) { - eset *set = (eset*) env; + pset *set = (pset*) env; if (get_irn_link(node) == MARK) { /* already visited */ @@ -456,7 +456,7 @@ static void free_ana_walker(ir_node *node, void *env) * which is sometimes used to anchor functions. */ static void add_method_address_inititializer(ir_initializer_t *initializer, - eset *set) + pset *set) { ir_node *n; size_t i; @@ -470,7 +470,7 @@ static void add_method_address_inititializer(ir_initializer_t *initializer, ir_entity *ent = get_SymConst_entity(n); if (is_Method_type(get_entity_type(ent))) - eset_insert(set, ent); + pset_insert_ptr(set, ent); } return; case IR_INITIALIZER_TARVAL: @@ -498,7 +498,7 @@ static void add_method_address_inititializer(ir_initializer_t *initializer, * * which is sometimes used to anchor functions. */ -static void add_method_address(ir_entity *ent, eset *set) +static void add_method_address(ir_entity *ent, pset *set) { ir_type *tp; @@ -521,7 +521,7 @@ static void add_method_address(ir_entity *ent, eset *set) ir_entity *ent2 = get_SymConst_entity(irn); if (is_Method_type(get_entity_type(ent2))) - eset_insert(set, ent2); + pset_insert_ptr(set, ent2); } } } @@ -539,7 +539,7 @@ static void add_method_address(ir_entity *ent, eset *set) */ static size_t get_free_methods(ir_entity ***free_methods) { - eset *free_set = eset_create(); + pset *free_set = pset_new_ptr_default(); size_t i, n, j, m; ir_entity **arr; ir_entity *ent; @@ -554,7 +554,7 @@ static size_t get_free_methods(ir_entity ***free_methods) linkage = get_entity_linkage(ent); if ((linkage & IR_LINKAGE_HIDDEN_USER) || entity_is_externally_visible(ent)) { - eset_insert(free_set, ent); + pset_insert_ptr(free_set, ent); } ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK); @@ -579,15 +579,16 @@ static size_t get_free_methods(ir_entity ***free_methods) /* the main program is even then "free", if it's not external visible. */ irg = get_irp_main_irg(); if (irg != NULL) - eset_insert(free_set, get_irg_entity(irg)); + pset_insert_ptr(free_set, get_irg_entity(irg)); /* Finally, transform the set into an array. */ - length = eset_count(free_set); + length = pset_count(free_set); arr = XMALLOCN(ir_entity*, length); - for (i = 0, ent = (ir_entity*) eset_first(free_set); ent; ent = (ir_entity*) eset_next(free_set)) { + i = 0; + foreach_pset(free_set, ir_entity*, ent) { arr[i++] = ent; } - eset_destroy(free_set); + del_pset(free_set); *free_methods = arr; return length; @@ -597,9 +598,9 @@ static size_t get_free_methods(ir_entity ***free_methods) /* Callee analysis. */ /*--------------------------------------------------------------------------*/ -static void callee_ana_node(ir_node * node, eset * methods); +static void callee_ana_node(ir_node *node, pset *methods); -static void callee_ana_proj(ir_node *node, long n, eset *methods) +static void callee_ana_proj(ir_node *node, long n, pset *methods) { assert(get_irn_mode(node) == mode_T); if (get_irn_link(node) == MARK) { @@ -618,7 +619,7 @@ static void callee_ana_proj(ir_node *node, long n, eset *methods) if (is_Tuple(pred)) { callee_ana_proj(get_Tuple_pred(pred, get_Proj_proj(node)), n, methods); } else { - eset_insert(methods, unknown_entity); /* free method -> unknown */ + pset_insert_ptr(methods, unknown_entity); /* free method -> unknown */ } } break; @@ -629,7 +630,7 @@ static void callee_ana_proj(ir_node *node, long n, eset *methods) break; default: - eset_insert(methods, unknown_entity); /* free method -> unknown */ + pset_insert_ptr(methods, unknown_entity); /* free method -> unknown */ break; } } @@ -640,7 +641,7 @@ static void callee_ana_proj(ir_node *node, long n, eset *methods) * @param node the node representing the call address * @param methods after call contains the set of all possibly called entities */ -static void callee_ana_node(ir_node *node, eset *methods) +static void callee_ana_node(ir_node *node, pset *methods) { assert(mode_is_reference(get_irn_mode(node)) || is_Bad(node)); /* Beware of recursion */ @@ -654,13 +655,13 @@ static void callee_ana_node(ir_node *node, eset *methods) case iro_Const: /* A direct address call. We tread this as an external call and ignore it completely. */ - eset_insert(methods, unknown_entity); /* free method -> unknown */ + pset_insert_ptr(methods, unknown_entity); /* free method -> unknown */ break; case iro_SymConst: { ir_entity *ent = get_SymConst_entity(node); assert(ent && is_method_entity(ent)); - eset_insert(methods, ent); + pset_insert_ptr(methods, ent); break; } @@ -670,9 +671,9 @@ static void callee_ana_node(ir_node *node, eset *methods) for (i = 0, n = get_Sel_n_methods(node); i < n; ++i) { ir_entity *ent = get_Sel_method(node, i); if (ent != NULL) { - eset_insert(methods, ent); + pset_insert_ptr(methods, ent); } else { - eset_insert(methods, unknown_entity); + pset_insert_ptr(methods, unknown_entity); } } break; @@ -707,7 +708,7 @@ static void callee_ana_node(ir_node *node, eset *methods) case iro_Sub: case iro_Conv: /* extern */ - eset_insert(methods, unknown_entity); /* free method -> unknown */ + pset_insert_ptr(methods, unknown_entity); /* free method -> unknown */ break; default: @@ -724,14 +725,15 @@ static void callee_walker(ir_node *call, void *env) { (void) env; if (is_Call(call)) { - eset *methods = eset_create(); + pset *methods = pset_new_ptr_default(); ir_entity *ent; ir_entity **arr; size_t i; callee_ana_node(get_Call_ptr(call), methods); - arr = NEW_ARR_F(ir_entity *, eset_count(methods)); - for (i = 0, ent = (ir_entity*) eset_first(methods); ent; ent = (ir_entity*) eset_next(methods)) { + arr = NEW_ARR_F(ir_entity*, pset_count(methods)); + i = 0; + foreach_pset(methods, ir_entity*, ent) { arr[i] = ent; /* we want the unknown_entity on the zero position for easy tests later */ if (ent == unknown_entity) { @@ -742,7 +744,7 @@ static void callee_walker(ir_node *call, void *env) } set_Call_callee_arr(call, ARR_LEN(arr), arr); DEL_ARR_F(arr); - eset_destroy(methods); + del_pset(methods); } } @@ -786,14 +788,14 @@ static void sel_methods_dispose(void) { ir_entity * ent; assert(entities); - for (ent = (ir_entity*) eset_first(entities); ent; ent = (ir_entity*) eset_next(entities)) { - ir_entity ** arr = (ir_entity**) get_entity_link(ent); - if (arr) { + foreach_pset(entities, ir_entity*, ent) { + ir_entity **arr = (ir_entity**) get_entity_link(ent); + if (arr != NULL) { DEL_ARR_F(arr); } set_entity_link(ent, NULL); } - eset_destroy(entities); + del_pset(entities); entities = NULL; } diff --git a/ir/ir/irdump.c b/ir/ir/irdump.c index 98d0bf805..08fb15e90 100644 --- a/ir/ir/irdump.c +++ b/ir/ir/irdump.c @@ -32,6 +32,7 @@ #include #include "list.h" +#include "pset.h" #include "irnode_t.h" #include "irgraph_t.h" @@ -61,7 +62,6 @@ #include "array.h" #include "pmap.h" #include "obst.h" -#include "eset.h" #include "pset.h" #include "util.h" @@ -2428,7 +2428,7 @@ void dump_callgraph_loop_tree(FILE *out) dump_vcg_footer(out); } -static void collect_nodeloop(FILE *F, ir_loop *loop, eset *loopnodes) +static void collect_nodeloop(FILE *F, ir_loop *loop, pset *loopnodes) { size_t i; int son_number = 0; @@ -2447,13 +2447,13 @@ static void collect_nodeloop(FILE *F, ir_loop *loop, eset *loopnodes) } else { if (flags & ir_dump_flag_loops) dump_loop_node_edge(F, loop, node_number++); - eset_insert(loopnodes, le.node); + pset_insert_ptr(loopnodes, le.node); } } } -static void collect_nodeloop_external_nodes(ir_loop *loop, eset *loopnodes, - eset *extnodes) +static void collect_nodeloop_external_nodes(ir_loop *loop, pset *loopnodes, + pset *extnodes) { size_t i; int j, start; @@ -2467,11 +2467,12 @@ static void collect_nodeloop_external_nodes(ir_loop *loop, eset *loopnodes, if (is_Block(le.node)) start = 0; else start = -1; for (j = start; j < get_irn_arity(le.node); j++) { ir_node *pred = get_irn_n(le.node, j); - if (!eset_contains(loopnodes, pred)) { - eset_insert(extnodes, pred); + if (!pset_find_ptr(loopnodes, pred)) { + pset_insert_ptr(extnodes, pred); if (!is_Block(pred)) { pred = get_nodes_block(pred); - if (!eset_contains(loopnodes, pred)) eset_insert(extnodes, pred); + if (!pset_find_ptr(loopnodes, pred)) + pset_insert_ptr(extnodes, pred); } } } @@ -2481,8 +2482,8 @@ static void collect_nodeloop_external_nodes(ir_loop *loop, eset *loopnodes, void dump_loop(FILE *F, ir_loop *l) { - eset *loopnodes = eset_create(); - eset *extnodes = eset_create(); + pset *loopnodes = pset_new_ptr_default(); + pset *extnodes = pset_new_ptr_default(); ir_node *n, *b; char name[50]; @@ -2494,20 +2495,20 @@ void dump_loop(FILE *F, ir_loop *l) collect_nodeloop_external_nodes(l, loopnodes, extnodes); /* build block lists */ - eset_foreach(loopnodes, ir_node*, n) { + foreach_pset(loopnodes, ir_node*, n) { set_irn_link(n, NULL); } - eset_foreach(extnodes, ir_node*, n) { + foreach_pset(extnodes, ir_node*, n) { set_irn_link(n, NULL); } - eset_foreach(loopnodes, ir_node*, n) { + foreach_pset(loopnodes, ir_node*, n) { if (!is_Block(n)) { b = get_nodes_block(n); set_irn_link(n, get_irn_link(b)); set_irn_link(b, n); } } - eset_foreach(extnodes, ir_node*, n) { + foreach_pset(extnodes, ir_node*, n) { if (!is_Block(n)) { b = get_nodes_block(n); set_irn_link(n, get_irn_link(b)); @@ -2515,7 +2516,7 @@ void dump_loop(FILE *F, ir_loop *l) } } - eset_foreach(loopnodes, ir_node*, b) { + foreach_pset(loopnodes, ir_node*, b) { if (is_Block(b)) { fprintf(F, "graph: { title: "); print_nodeid(F, b); @@ -2529,11 +2530,11 @@ void dump_loop(FILE *F, ir_loop *l) /* dump the nodes that go into the block */ for (n = (ir_node*)get_irn_link(b); n; n = (ir_node*)get_irn_link(n)) { - if (eset_contains(extnodes, n)) + if (pset_find_ptr(extnodes, n)) overrule_nodecolor = ird_color_block_inout; dump_node(F, n); overrule_nodecolor = ird_color_default_node; - if (!eset_contains(extnodes, n)) dump_ir_data_edges(F, n); + if (!pset_find_ptr(extnodes, n)) dump_ir_data_edges(F, n); } /* Close the vcg information for the block */ @@ -2542,7 +2543,7 @@ void dump_loop(FILE *F, ir_loop *l) fprintf(F, "\n"); } } - eset_foreach(extnodes, ir_node*, b) { + foreach_pset(extnodes, ir_node*, b) { if (is_Block(b)) { fprintf(F, "graph: { title: "); print_nodeid(F, b); @@ -2553,11 +2554,11 @@ void dump_loop(FILE *F, ir_loop *l) /* dump the nodes that go into the block */ for (n = (ir_node*)get_irn_link(b); n; n = (ir_node*)get_irn_link(n)) { - if (!eset_contains(loopnodes, n)) + if (!pset_find_ptr(loopnodes, n)) overrule_nodecolor = ird_color_block_inout; dump_node(F, n); overrule_nodecolor = ird_color_default_node; - if (eset_contains(loopnodes, n)) dump_ir_data_edges(F, n); + if (pset_find_ptr(loopnodes, n)) dump_ir_data_edges(F, n); } /* Close the vcg information for the block */ @@ -2566,8 +2567,8 @@ void dump_loop(FILE *F, ir_loop *l) fprintf(F, "\n"); } } - eset_destroy(loopnodes); - eset_destroy(extnodes); + del_pset(loopnodes); + del_pset(extnodes); dump_vcg_footer(F); }