From 97080a1af7b7e8a4969d2fba25e065df417ff074 Mon Sep 17 00:00:00 2001 From: Matthias Braun Date: Mon, 26 Nov 2012 18:13:13 +0100 Subject: [PATCH] get rid of get_irg_estimated_node_count We have simpler code without it, and a heuristic based on get_irg_last_idx() seems to work as well. --- include/libfirm/irgraph.h | 5 --- include/libfirm/irgwalk.h | 4 +- ir/ir/irdumptxt.c | 1 - ir/ir/iredges.c | 2 +- ir/ir/irgraph.c | 10 ----- ir/ir/irgraph_t.h | 6 --- ir/ir/irgwalk.c | 91 ++++++++++++--------------------------- ir/ir/irtypes.h | 2 - 8 files changed, 31 insertions(+), 90 deletions(-) diff --git a/include/libfirm/irgraph.h b/include/libfirm/irgraph.h index f645a6b23..3c892c25f 100644 --- a/include/libfirm/irgraph.h +++ b/include/libfirm/irgraph.h @@ -485,11 +485,6 @@ FIRM_API void set_irg_loc_description(ir_graph *irg, int n, void *description); /** Returns the description for local value n. */ FIRM_API void *get_irg_loc_description(ir_graph *irg, int n); -/** Returns a estimated node count of the irg. This count is updated - * after every irg_walk_graph(). - */ -FIRM_API unsigned get_irg_estimated_node_cnt(const ir_graph *irg); - /** Returns the last irn index for this graph. */ FIRM_API unsigned get_irg_last_idx(const ir_graph *irg); diff --git a/include/libfirm/irgwalk.h b/include/libfirm/irgwalk.h index b0ab2f37a..a4db46cc8 100644 --- a/include/libfirm/irgwalk.h +++ b/include/libfirm/irgwalk.h @@ -251,8 +251,8 @@ FIRM_API void irg_walk_anchors(ir_graph *irg, irg_walk_func *pre, * Walker function which does not increase the visited flag before walking. * Do not use this unless you know what you are doing. */ -unsigned irg_walk_2(ir_node *node, irg_walk_func *pre, irg_walk_func *post, - void *env); +FIRM_API void irg_walk_2(ir_node *node, irg_walk_func *pre, irg_walk_func *post, + void *env); /** @} */ diff --git a/ir/ir/irdumptxt.c b/ir/ir/irdumptxt.c index 9343d6aa5..48bf9ef3b 100644 --- a/ir/ir/irdumptxt.c +++ b/ir/ir/irdumptxt.c @@ -542,7 +542,6 @@ static void dump_entity_to_file_prefix(FILE *F, ir_entity *ent, const char *pref ir_graph *irg = get_entity_irg(ent); if (irg) { - fprintf(F, "%s estimated node count: %u\n", prefix, get_irg_estimated_node_cnt(irg)); fprintf(F, "%s maximum node index: %u\n", prefix, get_irg_last_idx(irg)); } diff --git a/ir/ir/iredges.c b/ir/ir/iredges.c index c8122e484..d6b4c7e5d 100644 --- a/ir/ir/iredges.c +++ b/ir/ir/iredges.c @@ -153,7 +153,7 @@ 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); - size_t amount = irg->estimated_node_count * 2; + size_t amount = get_irg_last_idx(irg) * 5 / 4; edges_used = 1; if (info->allocated) { diff --git a/ir/ir/irgraph.c b/ir/ir/irgraph.c index da37a9f19..8d924c7f4 100644 --- a/ir/ir/irgraph.c +++ b/ir/ir/irgraph.c @@ -216,7 +216,6 @@ ir_graph *new_r_ir_graph(ir_entity *ent, int n_loc) set_r_cur_block(res, first_block); res->method_execution_frequency = -1.0; - res->estimated_node_count = 0; return res; } @@ -383,10 +382,6 @@ ir_graph *create_irg_copy(ir_graph *irg) /* Proj results of start node */ set_irg_initial_mem(res, get_new_node(get_irg_initial_mem(irg))); - /* Copy the node count estimation. Would be strange if this - is different from the original one. */ - res->estimated_node_count = irg->estimated_node_count; - ir_free_resources(irg, IR_RESOURCE_IRN_LINK); irp_free_resources(irp, IRP_RESOURCE_ENTITY_LINK); @@ -703,11 +698,6 @@ ir_resources_t ir_resources_reserved(const ir_graph *irg) } #endif -unsigned (get_irg_estimated_node_cnt)(const ir_graph *irg) -{ - return get_irg_estimated_node_cnt_(irg); -} - unsigned get_irg_last_idx(const ir_graph *irg) { return irg->last_node_idx; diff --git a/ir/ir/irgraph_t.h b/ir/ir/irgraph_t.h index 7a7621726..f2bfe6355 100644 --- a/ir/ir/irgraph_t.h +++ b/ir/ir/irgraph_t.h @@ -76,7 +76,6 @@ #define set_irg_block_visited(irg, v) set_irg_block_visited_(irg, v) #define inc_irg_block_visited(irg) inc_irg_block_visited_(irg) #define dec_irg_block_visited(irg) dec_irg_block_visited_(irg) -#define get_irg_estimated_node_cnt(irg) get_irg_estimated_node_cnt_(irg) #define get_irg_fp_model(irg) get_irg_fp_model_(irg) #define get_idx_irn(irg, idx) get_idx_irn_(irg, idx) #define irg_is_constrained(irg, constraints) irg_is_constrained_(irg, constraints) @@ -322,11 +321,6 @@ static inline void dec_irg_block_visited_(ir_graph *irg) --irg->block_visited; } -static inline unsigned get_irg_estimated_node_cnt_(const ir_graph *irg) -{ - return irg->estimated_node_count; -} - /* Return the floating point model of this graph. */ static inline unsigned get_irg_fp_model_(const ir_graph *irg) { diff --git a/ir/ir/irgwalk.c b/ir/ir/irgwalk.c index b523e4da2..11e7d3266 100644 --- a/ir/ir/irgwalk.c +++ b/ir/ir/irgwalk.c @@ -44,13 +44,10 @@ /** * specialized version of irg_walk_2, called if only pre callback exists - * - * @return number of visited nodes */ -static unsigned irg_walk_2_pre(ir_node *node, irg_walk_func *pre, void *env) +static void irg_walk_2_pre(ir_node *node, irg_walk_func *pre, void *env) { int i; - unsigned cnt = 1; ir_graph *irg = get_irn_irg(node); set_irn_visited(node, irg->visited); @@ -60,25 +57,21 @@ static unsigned irg_walk_2_pre(ir_node *node, irg_walk_func *pre, void *env) if (!is_Block(node)) { ir_node *pred = get_nodes_block(node); if (pred->visited < irg->visited) - cnt += irg_walk_2_pre(pred, pre, env); + irg_walk_2_pre(pred, pre, env); } for (i = get_irn_arity(node) - 1; i >= 0; --i) { ir_node *pred = get_irn_n(node, i); if (pred->visited < irg->visited) - cnt += irg_walk_2_pre(pred, pre, env); + irg_walk_2_pre(pred, pre, env); } - return cnt; } /** * specialized version of irg_walk_2, called if only post callback exists - * - * @return number of visited nodes */ -static unsigned irg_walk_2_post(ir_node *node, irg_walk_func *post, void *env) +static void irg_walk_2_post(ir_node *node, irg_walk_func *post, void *env) { int i; - unsigned cnt = 1; ir_graph *irg = get_irn_irg(node); set_irn_visited(node, irg->visited); @@ -86,29 +79,24 @@ static unsigned irg_walk_2_post(ir_node *node, irg_walk_func *post, void *env) if (!is_Block(node)) { ir_node *pred = get_nodes_block(node); if (pred->visited < irg->visited) - cnt += irg_walk_2_post(pred, post, env); + irg_walk_2_post(pred, post, env); } for (i = get_irn_arity(node) - 1; i >= 0; --i) { ir_node *pred = get_irn_n(node, i); if (pred->visited < irg->visited) - cnt += irg_walk_2_post(pred, post, env); + irg_walk_2_post(pred, post, env); } post(node, env); - - return cnt; } /** * specialized version of irg_walk_2, called if pre and post callbacks exist - * - * @return number of visited nodes */ -static unsigned irg_walk_2_both(ir_node *node, irg_walk_func *pre, +static void irg_walk_2_both(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env) { int i; - unsigned cnt = 1; ir_graph *irg = get_irn_irg(node); set_irn_visited(node, irg->visited); @@ -118,38 +106,33 @@ static unsigned irg_walk_2_both(ir_node *node, irg_walk_func *pre, if (!is_Block(node)) { ir_node *pred = get_nodes_block(node); if (pred->visited < irg->visited) - cnt += irg_walk_2_both(pred, pre, post, env); + irg_walk_2_both(pred, pre, post, env); } for (i = get_irn_arity(node) - 1; i >= 0; --i) { ir_node *pred = get_irn_n(node, i); if (pred->visited < irg->visited) - cnt += irg_walk_2_both(pred, pre, post, env); + irg_walk_2_both(pred, pre, post, env); } post(node, env); - - return cnt; } -unsigned irg_walk_2(ir_node *node, irg_walk_func *pre, irg_walk_func *post, - void *env) +void irg_walk_2(ir_node *node, irg_walk_func *pre, irg_walk_func *post, + void *env) { if (irn_visited(node)) - return 0; + return; - if (!post) return irg_walk_2_pre (node, pre, env); - else if (!pre) return irg_walk_2_post(node, post, env); - else return irg_walk_2_both(node, pre, post, env); + if (!post) irg_walk_2_pre (node, pre, env); + else if (!pre) irg_walk_2_post(node, post, env); + else irg_walk_2_both(node, pre, post, env); } -/* a counter */ -static unsigned nodes_touched = 0; - void irg_walk_core(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env) { assert(is_ir_node(node)); - nodes_touched = irg_walk_2(node, pre, post, env); + irg_walk_2(node, pre, post, env); } void irg_walk(ir_node *node, irg_walk_func *pre, irg_walk_func *post, @@ -173,7 +156,6 @@ void irg_walk_graph(ir_graph *irg, irg_walk_func *pre, irg_walk_func *post, void hook_irg_walk(irg, (generic_func *)pre, (generic_func *)post); current_ir_graph = irg; irg_walk(get_irg_end(irg), pre, post, env); - irg->estimated_node_count = nodes_touched; current_ir_graph = rem; } @@ -190,13 +172,10 @@ void all_irg_walk(irg_walk_func *pre, irg_walk_func *post, void *env) /** * specialized version of irg_walk_in_or_dep_2, called if only pre callback exists - * - * @return number of visited nodes */ -static unsigned irg_walk_in_or_dep_2_pre(ir_node *node, irg_walk_func *pre, void *env) +static void irg_walk_in_or_dep_2_pre(ir_node *node, irg_walk_func *pre, void *env) { int i; - unsigned cnt = 1; ir_graph *irg = get_irn_irg(node); set_irn_visited(node, irg->visited); @@ -206,25 +185,21 @@ static unsigned irg_walk_in_or_dep_2_pre(ir_node *node, irg_walk_func *pre, void if (!is_Block(node)) { ir_node *pred = get_nodes_block(node); if (pred->visited < irg->visited) - cnt += irg_walk_in_or_dep_2_pre(pred, pre, env); + irg_walk_in_or_dep_2_pre(pred, pre, env); } for (i = get_irn_ins_or_deps(node) - 1; i >= 0; --i) { ir_node *pred = get_irn_in_or_dep(node, i); if (pred->visited < irg->visited) - cnt += irg_walk_in_or_dep_2_pre(pred, pre, env); + irg_walk_in_or_dep_2_pre(pred, pre, env); } - return cnt; } /** * specialized version of irg_walk_in_or_dep_2, called if only post callback exists - * - * @return number of visited nodes */ -static unsigned irg_walk_in_or_dep_2_post(ir_node *node, irg_walk_func *post, void *env) +static void irg_walk_in_or_dep_2_post(ir_node *node, irg_walk_func *post, void *env) { int i; - unsigned cnt = 1; ir_graph *irg = get_irn_irg(node); set_irn_visited(node, irg->visited); @@ -232,28 +207,23 @@ static unsigned irg_walk_in_or_dep_2_post(ir_node *node, irg_walk_func *post, vo if (!is_Block(node)) { ir_node *pred = get_nodes_block(node); if (pred->visited < irg->visited) - cnt += irg_walk_in_or_dep_2_post(pred, post, env); + irg_walk_in_or_dep_2_post(pred, post, env); } for (i = get_irn_ins_or_deps(node) - 1; i >= 0; --i) { ir_node *pred = get_irn_in_or_dep(node, i); if (pred->visited < irg->visited) - cnt += irg_walk_in_or_dep_2_post(pred, post, env); + irg_walk_in_or_dep_2_post(pred, post, env); } post(node, env); - - return cnt; } /** * specialized version of irg_walk_in_or_dep_2, called if pre and post callbacks exist - * - * @return number of visited nodes */ -static unsigned irg_walk_in_or_dep_2_both(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env) +static void irg_walk_in_or_dep_2_both(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env) { int i; - unsigned cnt = 1; ir_graph *irg = get_irn_irg(node); set_irn_visited(node, irg->visited); @@ -263,28 +233,24 @@ static unsigned irg_walk_in_or_dep_2_both(ir_node *node, irg_walk_func *pre, irg if (!is_Block(node)) { ir_node *pred = get_nodes_block(node); if (pred->visited < irg->visited) - cnt += irg_walk_in_or_dep_2_both(pred, pre, post, env); + irg_walk_in_or_dep_2_both(pred, pre, post, env); } for (i = get_irn_ins_or_deps(node) - 1; i >= 0; --i) { ir_node *pred = get_irn_in_or_dep(node, i); if (pred->visited < irg->visited) - cnt += irg_walk_in_or_dep_2_both(pred, pre, post, env); + irg_walk_in_or_dep_2_both(pred, pre, post, env); } post(node, env); - - return cnt; } /** * Intraprozedural graph walker. Follows dependency edges as well. - * - * @return number of visited nodes */ -static unsigned irg_walk_in_or_dep_2(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env) +static void irg_walk_in_or_dep_2(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env) { if (irn_visited(node)) - return 0; + return; if (! post) return irg_walk_in_or_dep_2_pre (node, pre, env); else if (! pre) return irg_walk_in_or_dep_2_post(node, post, env); @@ -297,7 +263,7 @@ void irg_walk_in_or_dep(ir_node *node, irg_walk_func *pre, irg_walk_func *post, ir_reserve_resources(current_ir_graph, IR_RESOURCE_IRN_VISITED); inc_irg_visited(current_ir_graph); - nodes_touched = irg_walk_in_or_dep_2(node, pre, post, env); + irg_walk_in_or_dep_2(node, pre, post, env); ir_free_resources(current_ir_graph, IR_RESOURCE_IRN_VISITED); } @@ -308,7 +274,6 @@ void irg_walk_in_or_dep_graph(ir_graph *irg, irg_walk_func *pre, irg_walk_func * hook_irg_walk(irg, (generic_func *)pre, (generic_func *)post); current_ir_graph = irg; irg_walk_in_or_dep(get_irg_end(irg), pre, post, env); - irg->estimated_node_count = nodes_touched; current_ir_graph = rem; } diff --git a/ir/ir/irtypes.h b/ir/ir/irtypes.h index 6109beb40..9138099ae 100644 --- a/ir/ir/irtypes.h +++ b/ir/ir/irtypes.h @@ -560,8 +560,6 @@ struct ir_graph { ir_visited_t self_visited; /**< visited flag of the irg */ - unsigned estimated_node_count; /**< estimated number of nodes in this graph, - updated after every walk */ irg_edges_info_t edge_info; /**< edge info for automatic outs */ ir_node **idx_irn_map; /**< Array mapping node indexes to nodes. */ -- 2.20.1