X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fstat%2Ffirmstat.c;h=e05961f07708983aad7f56613e3a3121e912297f;hb=2af4a97900b435e35d7c20350604e3863aff2b4c;hp=03834046b929837e5f2664451c80f6ec8050bf6b;hpb=eb08138c6b80c169945568e4414f491a9bc20388;p=libfirm diff --git a/ir/stat/firmstat.c b/ir/stat/firmstat.c index 03834046b..e05961f07 100644 --- a/ir/stat/firmstat.c +++ b/ir/stat/firmstat.c @@ -1,5 +1,5 @@ /* - * 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. * @@ -17,35 +17,25 @@ * PURPOSE. */ -/* - * Project: libFIRM - * File name: ir/ir/firmstat.c - * Purpose: Statistics for Firm. - * Author: Michael Beck - * Created: - * CVS-ID: $Id$ - * Copyright: (c) 2004 Universität Karlsruhe +/** + * @file + * @brief Statistics for Firm. + * @author Michael Beck + * @version $Id$ */ - -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif +#include "config.h" #ifdef FIRM_STATISTICS #include - -#ifdef HAVE_STDLIB_H -# include -#endif -#ifdef HAVE_STRING_H -# include -#endif +#include +#include #include "irouts.h" #include "irdump.h" #include "hashptr.h" #include "firmstat_t.h" +#include "irpass_t.h" #include "pattern.h" #include "dags.h" #include "stat_dmp.h" @@ -77,6 +67,9 @@ static ir_op _op_ModC; /** The Div by Const node. */ static ir_op _op_DivModC; +/** The Quot by Const node. */ +static ir_op _op_QuotC; + /** The memory Proj node. */ static ir_op _op_ProjM; @@ -100,7 +93,7 @@ static ir_op _op_SelSelSel; /** * global status */ -static const int status_disable = 0; +static const unsigned status_disable = 0; static stat_info_t *status = (stat_info_t *)&status_disable; /** @@ -140,6 +133,7 @@ static int block_cmp(const void *elt, const void *key) { const block_entry_t *e1 = elt; const block_entry_t *e2 = key; + /* it's enough to compare the block number */ return e1->block_nr != e2->block_nr; } /* block_cmp */ @@ -199,6 +193,7 @@ static int opcode_cmp_2(const void *elt, const void *key) { static int address_mark_cmp(const void *elt, const void *key, size_t size) { const address_mark_entry_t *e1 = elt; const address_mark_entry_t *e2 = key; + (void) size; /* compare only the nodes, the rest is used as data container */ return e1->node != e2->node; @@ -211,10 +206,12 @@ static void opcode_clear_entry(node_entry_t *elem) { cnt_clr(&elem->cnt_alive); cnt_clr(&elem->new_node); cnt_clr(&elem->into_Id); + cnt_clr(&elem->normalized); } /* opcode_clear_entry */ /** - * Returns the associates node_entry_t for an ir_op + * Returns the associates node_entry_t for an ir_op (and allocates + * one if not yet available). * * @param op the IR operation * @param hmap a hash map containing ir_op* -> node_entry_t* @@ -229,8 +226,7 @@ static node_entry_t *opcode_get_entry(const ir_op *op, hmap_node_entry_t *hmap) if (elem) return elem; - elem = obstack_alloc(&status->cnts, sizeof(*elem)); - memset(elem, 0, sizeof(*elem)); + elem = OALLOCZ(&status->cnts, node_entry_t); /* clear counter */ opcode_clear_entry(elem); @@ -262,7 +258,7 @@ static ir_op *opcode_find_entry(ir_opcode code, hmap_ir_op *hmap) { static void graph_clear_entry(graph_entry_t *elem, int all) { int i; - /* clear accumulated / non-acumulated counter */ + /* clear accumulated / non-accumulated counter */ for (i = all ? 0 : _gcnt_non_acc; i < _gcnt_last; ++i) { cnt_clr(&elem->cnt[i]); } /* for */ @@ -284,14 +280,14 @@ static void graph_clear_entry(graph_entry_t *elem, int all) { /** * Returns the associated graph_entry_t for an IR graph. * - * @param irg the IR graph + * @param irg the IR graph, NULL for the global counter * @param hmap the hash map containing ir_graph* -> graph_entry_t* */ static graph_entry_t *graph_get_entry(ir_graph *irg, hmap_graph_entry_t *hmap) { graph_entry_t key; graph_entry_t *elem; - int i; + size_t i; key.irg = irg; @@ -306,8 +302,7 @@ static graph_entry_t *graph_get_entry(ir_graph *irg, hmap_graph_entry_t *hmap) } /* if */ /* allocate a new one */ - elem = obstack_alloc(&status->cnts, sizeof(*elem)); - memset(elem, 0, sizeof(*elem)); + elem = OALLOCZ(&status->cnts, graph_entry_t); obstack_init(&elem->recalc_cnts); /* clear counter */ @@ -352,8 +347,7 @@ static opt_entry_t *opt_get_entry(const ir_op *op, hmap_opt_entry_t *hmap) if (elem) return elem; - elem = obstack_alloc(&status->cnts, sizeof(*elem)); - memset(elem, 0, sizeof(*elem)); + elem = OALLOCZ(&status->cnts, opt_entry_t); /* clear new counter */ opt_clear_entry(elem); @@ -390,8 +384,7 @@ static block_entry_t *block_get_entry(struct obstack *obst, long block_nr, hmap_ if (elem) return elem; - elem = obstack_alloc(obst, sizeof(*elem)); - memset(elem, 0, sizeof(*elem)); + elem = OALLOCZ(obst, block_entry_t); /* clear new counter */ block_clear_entry(elem); @@ -437,8 +430,7 @@ static be_block_entry_t *be_block_get_entry(struct obstack *obst, long block_nr, if (elem) return elem; - elem = obstack_alloc(obst, sizeof(*elem)); - memset(elem, 0, sizeof(*elem)); + elem = OALLOCZ(obst, be_block_entry_t); /* clear new counter */ be_block_clear_entry(elem); @@ -476,8 +468,7 @@ static perm_class_entry_t *perm_class_get_entry(struct obstack *obst, const char if (elem) return elem; - elem = obstack_alloc(obst, sizeof(*elem)); - memset(elem, 0, sizeof(*elem)); + elem = OALLOCZ(obst, perm_class_entry_t); /* clear new counter */ perm_class_clear_entry(elem); @@ -518,8 +509,7 @@ static perm_stat_entry_t *perm_stat_get_entry(struct obstack *obst, ir_node *per if (elem) return elem; - elem = obstack_alloc(obst, sizeof(*elem)); - memset(elem, 0, sizeof(*elem)); + elem = OALLOCZ(obst, perm_stat_entry_t); /* clear new counter */ perm_stat_clear_entry(elem); @@ -529,6 +519,15 @@ static perm_stat_entry_t *perm_stat_get_entry(struct obstack *obst, ir_node *per return pset_insert(hmap, elem, HASH_PTR(perm)); } /* perm_stat_get_entry */ +/** + * Clear optimizations counter, + */ +static void clear_optimization_counter(void) { + int i; + for (i = 0; i < FS_OPT_MAX; ++i) + cnt_clr(&status->num_opts[i]); +} + /** * Returns the ir_op for an IR-node, * handles special cases and return pseudo op codes. @@ -557,34 +556,40 @@ static ir_op *stat_get_irn_op(ir_node *node) } /* if */ break; case iro_Mul: - if (get_irn_op(get_Mul_left(node)) == op_Const || get_irn_op(get_Mul_right(node)) == op_Const) { + if (is_Const(get_Mul_left(node)) || is_Const(get_Mul_right(node))) { /* special case, a Multiply by a const, count on extra counter */ op = status->op_MulC ? status->op_MulC : op; } /* if */ break; case iro_Div: - if (get_irn_op(get_Div_right(node)) == op_Const) { + if (is_Const(get_Div_right(node))) { /* special case, a division by a const, count on extra counter */ op = status->op_DivC ? status->op_DivC : op; } /* if */ break; case iro_Mod: - if (get_irn_op(get_Mod_right(node)) == op_Const) { + if (is_Const(get_Mod_right(node))) { /* special case, a module by a const, count on extra counter */ op = status->op_ModC ? status->op_ModC : op; } /* if */ break; case iro_DivMod: - if (get_irn_op(get_DivMod_right(node)) == op_Const) { + if (is_Const(get_DivMod_right(node))) { /* special case, a division/modulo by a const, count on extra counter */ op = status->op_DivModC ? status->op_DivModC : op; } /* if */ break; + case iro_Quot: + if (is_Const(get_Quot_right(node))) { + /* special case, a floating point division by a const, count on extra counter */ + op = status->op_QuotC ? status->op_QuotC : op; + } /* if */ + break; case iro_Sel: - if (get_irn_op(get_Sel_ptr(node)) == op_Sel) { + if (is_Sel(get_Sel_ptr(node))) { /* special case, a Sel of a Sel, count on extra counter */ op = status->op_SelSel ? status->op_SelSel : op; - if (get_irn_op(get_Sel_ptr(get_Sel_ptr(node))) == op_Sel) { + if (is_Sel(get_Sel_ptr(get_Sel_ptr(node)))) { /* special case, a Sel of a Sel of a Sel, count on extra counter */ op = status->op_SelSelSel ? status->op_SelSelSel : op; } /* if */ @@ -611,6 +616,11 @@ static void undate_block_info(ir_node *node, graph_entry_t *graph) if (op == op_Block) { arity = get_irn_arity(node); b_entry = block_get_entry(&graph->recalc_cnts, get_irn_node_nr(node), graph->block_hash); + /* mark start end block to allow to filter them out */ + if (node == get_irg_start_block(graph->irg)) + b_entry->is_start = 1; + else if (node == get_irg_end_block(graph->irg)) + b_entry->is_end = 1; /* count all incoming edges */ for (i = 0; i < arity; ++i) { @@ -636,7 +646,7 @@ static void undate_block_info(ir_node *node, graph_entry_t *graph) cnt_inc(&b_entry->cnt[bcnt_nodes]); /* don't count keep-alive edges */ - if (get_irn_op(node) == op_End) + if (is_End(node)) return; arity = get_irn_arity(node); @@ -701,7 +711,7 @@ static void update_extbb_info(ir_node *node, graph_entry_t *graph) cnt_inc(&eb_entry->cnt[bcnt_nodes]); /* don't count keep-alive edges */ - if (get_irn_op(node) == op_End) + if (is_End(node)) return; arity = get_irn_arity(node); @@ -783,7 +793,7 @@ static void stat_update_call(ir_node *call, graph_entry_t *graph) /* found a call, this function is not a leaf */ graph->is_leaf = 0; - if (get_irn_op(ptr) == op_SymConst) { + if (is_SymConst(ptr)) { if (get_SymConst_kind(ptr) == symconst_addr_ent) { /* ok, we seems to know the entity */ ent = get_SymConst_entity(ptr); @@ -792,6 +802,8 @@ static void stat_update_call(ir_node *call, graph_entry_t *graph) /* it is recursive, if it calls at least once */ if (callee == graph->irg) graph->is_recursive = 1; + if (callee == NULL) + cnt_inc(&graph->cnt[gcnt_external_calls]); } /* if */ } else { /* indirect call, be could not predict */ @@ -802,7 +814,7 @@ static void stat_update_call(ir_node *call, graph_entry_t *graph) } /* if */ /* check, if it's a chain-call: Then, the call-block - * must dominate the end block. */ + * must dominate the end block. */ { ir_node *curr = get_irg_end_block(graph->irg); int depth = get_Block_dom_depth(block); @@ -849,7 +861,7 @@ static void stat_update_call_2(ir_node *call, graph_entry_t *graph) if (is_Bad(block)) return; - if (get_irn_op(ptr) == op_SymConst) { + if (is_SymConst(ptr)) { if (get_SymConst_kind(ptr) == symconst_addr_ent) { /* ok, we seems to know the entity */ ent = get_SymConst_entity(ptr); @@ -947,7 +959,7 @@ static void update_node_stat(ir_node *node, void *env) node_entry_t *entry; ir_op *op = stat_get_irn_op(node); - int arity = get_irn_arity(node); + int i, arity = get_irn_arity(node); entry = opcode_get_entry(op, graph->opcode_hash); @@ -966,12 +978,6 @@ static void update_node_stat(ir_node *node, void *env) /* handle statistics for special node types */ switch (op->code) { - case iro_Const: - if (status->stat_options & FIRMSTAT_COUNT_CONSTS) { - /* check properties of constants */ - stat_update_const(status, node, graph); - } /* if */ - break; case iro_Call: /* check for properties that depends on calls like recursion/leaf/indirect call */ stat_update_call(node, graph); @@ -984,9 +990,33 @@ static void update_node_stat(ir_node *node, void *env) /* check address properties */ stat_update_address(get_Store_ptr(node), graph); break; + case iro_Phi: + /* check for non-strict Phi nodes */ + for (i = arity - 1; i >= 0; --i) { + ir_node *pred = get_Phi_pred(node, i); + if (is_Unknown(pred)) { + /* found an Unknown predecessor, graph is not strict */ + graph->is_strict = 0; + break; + } + } default: ; } /* switch */ + + /* we want to count the constant IN nodes, not the CSE'ed constant's itself */ + if (status->stat_options & FIRMSTAT_COUNT_CONSTS) { + int i; + + for (i = get_irn_arity(node) - 1; i >= 0; --i) { + ir_node *pred = get_irn_n(node, i); + + if (is_Const(pred)) { + /* check properties of constants */ + stat_update_const(status, pred, graph); + } /* if */ + } /* for */ + } /* if */ } /* update_node_stat */ /** @@ -1082,7 +1112,7 @@ static void mark_address_calc(ir_node *node, void *env) { int i, n; unsigned mark_preds = MARK_REF_NON_ADR; - if (! mode_is_numP(mode)) + if (! mode_is_data(mode)) return; if (mode_is_reference(mode)) { @@ -1107,7 +1137,7 @@ static void mark_address_calc(ir_node *node, void *env) { ir_node *pred = get_irn_n(node, i); mode = get_irn_op_mode(pred); - if (! mode_is_numP(mode)) + if (! mode_is_data(mode)) continue; set_adr_mark(graph, pred, get_adr_mark(graph, pred) | mark_preds); @@ -1155,6 +1185,7 @@ static void update_graph_stat(graph_entry_t *global, graph_entry_t *graph) graph->is_leaf_call = LCS_UNKNOWN; graph->is_recursive = 0; graph->is_chain_call = 1; + graph->is_strict = 1; /* create new block counter */ graph->block_hash = new_pset(block_cmp, 5); @@ -1249,6 +1280,7 @@ static void update_graph_stat(graph_entry_t *global, graph_entry_t *graph) */ static void update_graph_stat_2(graph_entry_t *global, graph_entry_t *graph) { + (void) global; if (graph->is_deleted) { /* deleted, ignore */ return; @@ -1267,15 +1299,13 @@ static void update_graph_stat_2(graph_entry_t *global, graph_entry_t *graph) * Register a dumper. */ static void stat_register_dumper(const dumper_t *dumper) { - dumper_t *p = xmalloc(sizeof(*p)); + dumper_t *p = XMALLOC(dumper_t); - if (p) { - memcpy(p, dumper, sizeof(*p)); + memcpy(p, dumper, sizeof(*p)); - p->next = status->dumper; - p->status = status; - status->dumper = p; - } + p->next = status->dumper; + p->status = status; + status->dumper = p; /* FIXME: memory leak */ } /* stat_register_dumper */ @@ -1327,10 +1357,22 @@ static void stat_dump_param_tbl(const distrib_tbl_t *tbl, graph_entry_t *global) dumper_t *dumper; for (dumper = status->dumper; dumper; dumper = dumper->next) { - if (dumper->dump_const_tbl) + if (dumper->dump_param_tbl) dumper->dump_param_tbl(dumper, tbl, global); } /* for */ -} +} /* stat_dump_param_tbl */ + +/** + * Dumps the optimization counter + */ +static void stat_dump_opt_cnt(const counter_t *tbl, unsigned len) { + dumper_t *dumper; + + for (dumper = status->dumper; dumper; dumper = dumper->next) { + if (dumper->dump_opt_cnt) + dumper->dump_opt_cnt(dumper, tbl, len); + } /* for */ +} /* stat_dump_opt_cnt */ /** * Initialize the dumper. @@ -1385,6 +1427,7 @@ ir_op *stat_get_op_from_opcode(ir_opcode code) { * @param op the new IR opcode that was created. */ static void stat_new_ir_op(void *ctx, ir_op *op) { + (void) ctx; if (! status->stat_options) return; @@ -1407,6 +1450,8 @@ static void stat_new_ir_op(void *ctx, ir_op *op) { * @param op the IR opcode that is freed */ static void stat_free_ir_op(void *ctx, ir_op *op) { + (void) ctx; + (void) op; if (! status->stat_options) return; @@ -1424,6 +1469,8 @@ static void stat_free_ir_op(void *ctx, ir_op *op) { * @param node the new IR node that was created */ static void stat_new_node(void *ctx, ir_graph *irg, ir_node *node) { + (void) ctx; + (void) irg; if (! status->stat_options) return; @@ -1457,6 +1504,7 @@ static void stat_new_node(void *ctx, ir_graph *irg, ir_node *node) { * @param node the IR node that will be turned into an ID */ static void stat_turn_into_id(void *ctx, ir_node *node) { + (void) ctx; if (! status->stat_options) return; @@ -1479,6 +1527,36 @@ static void stat_turn_into_id(void *ctx, ir_node *node) { STAT_LEAVE; } /* stat_turn_into_id */ +/** + * Hook: A node is normalized + * + * @param ctx the hook context + * @param node the IR node that was normalized + */ +static void stat_normalize(void *ctx, ir_node *node) { + (void) ctx; + if (! status->stat_options) + return; + + STAT_ENTER; + { + node_entry_t *entry; + graph_entry_t *graph; + ir_op *op = stat_get_irn_op(node); + + /* increase global value */ + graph = graph_get_entry(NULL, status->irg_hash); + entry = opcode_get_entry(op, graph->opcode_hash); + cnt_inc(&entry->normalized); + + /* increase local value */ + graph = graph_get_entry(current_ir_graph, status->irg_hash); + entry = opcode_get_entry(op, graph->opcode_hash); + cnt_inc(&entry->normalized); + } + STAT_LEAVE; +} /* stat_normalize */ + /** * Hook: A new graph was created * @@ -1487,6 +1565,7 @@ static void stat_turn_into_id(void *ctx, ir_node *node) { * @param ent the entity of this graph */ static void stat_new_graph(void *ctx, ir_graph *irg, ir_entity *ent) { + (void) ctx; if (! status->stat_options) return; @@ -1501,6 +1580,7 @@ static void stat_new_graph(void *ctx, ir_graph *irg, ir_entity *ent) { graph->is_leaf_call = 0; graph->is_recursive = 0; graph->is_chain_call = 0; + graph->is_strict = 1; graph->is_analyzed = 0; } STAT_LEAVE; @@ -1517,6 +1597,7 @@ static void stat_new_graph(void *ctx, ir_graph *irg, ir_entity *ent) { * information from being changed, it's "frozen" from now. */ static void stat_free_graph(void *ctx, ir_graph *irg) { + (void) ctx; if (! status->stat_options) return; @@ -1545,6 +1626,9 @@ static void stat_free_graph(void *ctx, ir_graph *irg) { */ static void stat_irg_walk(void *ctx, ir_graph *irg, generic_func *pre, generic_func *post) { + (void) ctx; + (void) pre; + (void) post; if (! status->stat_options) return; @@ -1582,6 +1666,10 @@ static void stat_irg_walk_blkwise(void *ctx, ir_graph *irg, generic_func *pre, g */ static void stat_irg_block_walk(void *ctx, ir_graph *irg, ir_node *node, generic_func *pre, generic_func *post) { + (void) ctx; + (void) node; + (void) pre; + (void) post; if (! status->stat_options) return; @@ -1599,12 +1687,18 @@ static void stat_irg_block_walk(void *ctx, ir_graph *irg, ir_node *node, generic * * @param n the IR node that will be removed * @param hmap the hash map containing ir_op* -> opt_entry_t* + * @param kind the optimization kind */ -static void removed_due_opt(ir_node *n, hmap_opt_entry_t *hmap) { - ir_op *op = stat_get_irn_op(n); - opt_entry_t *entry = opt_get_entry(op, hmap); +static void removed_due_opt(ir_node *n, hmap_opt_entry_t *hmap, hook_opt_kind kind) { + opt_entry_t *entry; + ir_op *op = stat_get_irn_op(n); + + /* ignore CSE for Constants */ + if (kind == HOOK_OPT_CSE && (is_Const(n) || is_SymConst(n))) + return; /* increase global value */ + entry = opt_get_entry(op, hmap); cnt_inc(&entry->count); } /* removed_due_opt */ @@ -1619,6 +1713,7 @@ static void stat_merge_nodes( ir_node **old_node_array, int old_num_entries, hook_opt_kind opt) { + (void) ctx; if (! status->stat_options) return; @@ -1627,6 +1722,7 @@ static void stat_merge_nodes( int i, j; graph_entry_t *graph = graph_get_entry(current_ir_graph, status->irg_hash); + cnt_inc(&status->num_opts[opt]); if (status->reassoc_run) opt = HOOK_OPT_REASSOC; @@ -1648,7 +1744,7 @@ static void stat_merge_nodes( xopt = HOOK_OPT_CONFIRM_C; } /* if */ - removed_due_opt(old_node_array[i], graph->opt_hash[xopt]); + removed_due_opt(old_node_array[i], graph->opt_hash[xopt], xopt); } /* if */ } /* for */ } @@ -1662,6 +1758,7 @@ static void stat_merge_nodes( * @param flag if non-zero, reassociation is started else stopped */ static void stat_reassociate(void *ctx, int flag) { + (void) ctx; if (! status->stat_options) return; @@ -1679,6 +1776,7 @@ static void stat_reassociate(void *ctx, int flag) { * @param node the IR node that will be lowered */ static void stat_lower(void *ctx, ir_node *node) { + (void) ctx; if (! status->stat_options) return; @@ -1686,7 +1784,7 @@ static void stat_lower(void *ctx, ir_node *node) { { graph_entry_t *graph = graph_get_entry(current_ir_graph, status->irg_hash); - removed_due_opt(node, graph->opt_hash[HOOK_LOWERED]); + removed_due_opt(node, graph->opt_hash[HOOK_LOWERED], HOOK_LOWERED); } STAT_LEAVE; } /* stat_lower */ @@ -1701,6 +1799,7 @@ static void stat_lower(void *ctx, ir_node *node) { */ static void stat_inline(void *ctx, ir_node *call, ir_graph *called_irg) { + (void) ctx; if (! status->stat_options) return; @@ -1722,6 +1821,7 @@ static void stat_inline(void *ctx, ir_node *call, ir_graph *called_irg) * @param ctx the hook context */ static void stat_tail_rec(void *ctx, ir_graph *irg, int n_calls) { + (void) ctx; if (! status->stat_options) return; @@ -1740,6 +1840,7 @@ static void stat_tail_rec(void *ctx, ir_graph *irg, int n_calls) { * @param ctx the hook context */ static void stat_strength_red(void *ctx, ir_graph *irg, ir_node *strong) { + (void) ctx; if (! status->stat_options) return; @@ -1748,7 +1849,7 @@ static void stat_strength_red(void *ctx, ir_graph *irg, ir_node *strong) { graph_entry_t *graph = graph_get_entry(irg, status->irg_hash); cnt_inc(&graph->cnt[gcnt_acc_strength_red]); - removed_due_opt(strong, graph->opt_hash[HOOK_OPT_STRENGTH_RED]); + removed_due_opt(strong, graph->opt_hash[HOOK_OPT_STRENGTH_RED], HOOK_OPT_STRENGTH_RED); } STAT_LEAVE; } /* stat_strength_red */ @@ -1759,6 +1860,8 @@ static void stat_strength_red(void *ctx, ir_graph *irg, ir_node *strong) { * @param ctx the hook context */ static void stat_dead_node_elim(void *ctx, ir_graph *irg, int start) { + (void) ctx; + (void) irg; if (! status->stat_options) return; @@ -1771,6 +1874,10 @@ static void stat_dead_node_elim(void *ctx, ir_graph *irg, int start) { static void stat_if_conversion(void *context, ir_graph *irg, ir_node *phi, int pos, ir_node *mux, if_result_t reason) { + (void) context; + (void) phi; + (void) pos; + (void) mux; if (! status->stat_options) return; @@ -1788,6 +1895,8 @@ static void stat_if_conversion(void *context, ir_graph *irg, ir_node *phi, */ static void stat_func_call(void *context, ir_graph *irg, ir_node *call) { + (void) context; + (void) call; if (! status->stat_options) return; @@ -1806,13 +1915,14 @@ static void stat_func_call(void *context, ir_graph *irg, ir_node *call) * @param ctx the hook context */ static void stat_arch_dep_replace_mul_with_shifts(void *ctx, ir_node *mul) { + (void) ctx; if (! status->stat_options) return; STAT_ENTER; { graph_entry_t *graph = graph_get_entry(current_ir_graph, status->irg_hash); - removed_due_opt(mul, graph->opt_hash[HOOK_OPT_ARCH_DEP]); + removed_due_opt(mul, graph->opt_hash[HOOK_OPT_ARCH_DEP], HOOK_OPT_ARCH_DEP); } STAT_LEAVE; } /* stat_arch_dep_replace_mul_with_shifts */ @@ -1824,13 +1934,14 @@ static void stat_arch_dep_replace_mul_with_shifts(void *ctx, ir_node *mul) { * @param node the division node that will be optimized */ static void stat_arch_dep_replace_division_by_const(void *ctx, ir_node *node) { + (void) ctx; if (! status->stat_options) return; STAT_ENTER; { graph_entry_t *graph = graph_get_entry(current_ir_graph, status->irg_hash); - removed_due_opt(node, graph->opt_hash[HOOK_OPT_ARCH_DEP]); + removed_due_opt(node, graph->opt_hash[HOOK_OPT_ARCH_DEP], HOOK_OPT_ARCH_DEP); } STAT_LEAVE; } /* stat_arch_dep_replace_division_by_const */ @@ -1855,8 +1966,7 @@ void stat_be_block_regpressure(ir_graph *irg, ir_node *block, int pressure, cons reg_pressure_entry_t *rp_ent; block_ent = be_block_get_entry(&status->be_data, get_irn_node_nr(block), graph->be_block_hash); - rp_ent = obstack_alloc(&status->be_data, sizeof(*rp_ent)); - memset(rp_ent, 0, sizeof(*rp_ent)); + rp_ent = OALLOCZ(&status->be_data, reg_pressure_entry_t); rp_ent->class_name = class_name; rp_ent->pressure = pressure; @@ -2005,7 +2115,7 @@ void stat_dump_snapshot(const char *name, const char *phase) ++p; l = p - name; - if (l > sizeof(fname) - 1) + if (l > (int) (sizeof(fname) - 1)) l = sizeof(fname) - 1; memcpy(fname, name, l); @@ -2014,10 +2124,10 @@ void stat_dump_snapshot(const char *name, const char *phase) fname[0] = '\0'; p = name; } /* if */ - strncat(fname, "firmstat-", sizeof(fname)); - strncat(fname, phase, sizeof(fname)); - strncat(fname, "-", sizeof(fname)); - strncat(fname, p, sizeof(fname)); + strncat(fname, "firmstat-", sizeof(fname)-1); + strncat(fname, phase, sizeof(fname)-1); + strncat(fname, "-", sizeof(fname)-1); + strncat(fname, p, sizeof(fname)-1); stat_dump_init(fname); @@ -2068,11 +2178,15 @@ void stat_dump_snapshot(const char *name, const char *phase) /* dump the parameter distribution */ stat_dump_param_tbl(status->dist_param_cnt, global); + /* dump the optimization counter and clear them */ + stat_dump_opt_cnt(status->num_opts, ARR_SIZE(status->num_opts)); + clear_optimization_counter(); + stat_dump_finish(); stat_finish_pattern_history(fname); - /* clear the global counter here */ + /* clear the global counters here */ { node_entry_t *entry; @@ -2080,12 +2194,66 @@ void stat_dump_snapshot(const char *name, const char *phase) opcode_clear_entry(entry); } /* for */ /* clear all global counter */ - graph_clear_entry(global, 1); + graph_clear_entry(global, /*all=*/1); } } STAT_LEAVE; } /* stat_dump_snapshot */ +struct pass_t { + ir_prog_pass_t pass; + const char *fname; + const char *phase; +}; + +/** + * Wrapper to run stat_dump_snapshot() as a ir_prog wrapper. + */ +static int stat_dump_snapshot_wrapper(ir_prog *irp, void *context) { + struct pass_t *pass = context; + + (void)irp; + stat_dump_snapshot(pass->fname, pass->phase); + return 0; +} /* stat_dump_snapshot_wrapper */ + +/** + * Ensure that no verifier is run from the wrapper. + */ +static int no_verify(ir_prog *prog, void *ctx) +{ + (void)prog; + (void)ctx; + return 0; +} + +/** + * Ensure that no dumper is run from the wrapper. + */ +static void no_dump(ir_prog *prog, void *ctx, unsigned idx) +{ + (void)prog; + (void)ctx; + (void)idx; +} + +/* create an ir_pog pass */ +ir_prog_pass_t *stat_dump_snapshot_pass( + const char *name, const char *fname, const char *phase) { + struct pass_t *pass = XMALLOCZ(struct pass_t); + + def_prog_pass_constructor( + &pass->pass, name ? name : "stat_snapshot", stat_dump_snapshot_wrapper); + pass->fname = fname; + pass->phase = phase; + + /* no dump/verify */ + pass->pass.dump_irprog = no_dump; + pass->pass.verify_irprog = no_verify; + + return &pass->pass; +} /* stat_dump_snapshot_pass */ + /** the hook entries for the Firm statistics module */ static hook_entry_t stat_hooks[hook_last]; @@ -2100,8 +2268,7 @@ void firm_init_stat(unsigned enable_options) if (! (enable_options & FIRMSTAT_ENABLED)) return; - status = xmalloc(sizeof(*status)); - memset(status, 0, sizeof(*status)); + status = XMALLOCZ(stat_info_t); /* enable statistics */ status->stat_options = enable_options & FIRMSTAT_ENABLED ? enable_options : 0; @@ -2111,6 +2278,7 @@ void firm_init_stat(unsigned enable_options) HOOK(hook_free_ir_op, stat_free_ir_op); HOOK(hook_new_node, stat_new_node); HOOK(hook_turn_into_id, stat_turn_into_id); + HOOK(hook_normalize, stat_normalize); HOOK(hook_new_graph, stat_new_graph); HOOK(hook_free_graph, stat_free_graph); HOOK(hook_irg_walk, stat_irg_walk); @@ -2162,6 +2330,9 @@ void firm_init_stat(unsigned enable_options) _op_DivModC.code = --num; _op_DivModC.name = new_id_from_chars(X("DivModC")); + _op_QuotC.code = --num; + _op_QuotC.name = new_id_from_chars(X("QuotC")); + status->op_Phi0 = &_op_Phi0; status->op_PhiM = &_op_PhiM; status->op_ProjM = &_op_ProjM; @@ -2169,6 +2340,7 @@ void firm_init_stat(unsigned enable_options) status->op_DivC = &_op_DivC; status->op_ModC = &_op_ModC; status->op_DivModC = &_op_DivModC; + status->op_QuotC = &_op_QuotC; } else { status->op_Phi0 = NULL; status->op_PhiM = NULL; @@ -2177,6 +2349,7 @@ void firm_init_stat(unsigned enable_options) status->op_DivC = NULL; status->op_ModC = NULL; status->op_DivModC = NULL; + status->op_QuotC = NULL; } /* if */ /* for Florian: count the Sel depth */ @@ -2210,6 +2383,8 @@ void firm_init_stat(unsigned enable_options) /* distribution table for parameter counts */ status->dist_param_cnt = stat_new_int_distrib_tbl(); + clear_optimization_counter(); + #undef HOOK #undef X } /* firm_init_stat */