/*
- * 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
- * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
+ * Copyright (C) 1995-2008 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 Statistics for Firm.
+ * @author Michael Beck
+ * @version $Id$
+ */
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
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;
{
graph_entry_t key;
graph_entry_t *elem;
- int i;
+ size_t i;
key.irg = irg;
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.
} /* for */
} /* update_extbb_info */
-/** Calculates how many arguments of the call are const. */
-static int cnt_const_args(ir_node *call) {
- int i, res = 0;
+/**
+ * Calculates how many arguments of the call are const, updates
+ * param distribution.
+ */
+static void analyse_params_of_Call(graph_entry_t *graph, ir_node *call) {
+ int i, num_const_args = 0, num_local_adr = 0;
int n = get_Call_n_params(call);
for (i = 0; i < n; ++i) {
ir_node *param = get_Call_param(call, i);
- ir_op *op = get_irn_op(param);
- if (op == op_Const || op == op_SymConst)
- ++res;
+ if (is_irn_constlike(param))
+ ++num_const_args;
+ else if (is_Sel(param)) {
+ ir_node *base = param;
+
+ do {
+ base = get_Sel_ptr(base);
+ } while (is_Sel(base));
+
+ if (base == get_irg_frame(current_ir_graph))
+ ++num_local_adr;
+ }
+
} /* for */
- return res;
-} /* cnt_const_args */
+
+ if (num_const_args > 0)
+ cnt_inc(&graph->cnt[gcnt_call_with_cnst_arg]);
+ if (num_const_args == n)
+ cnt_inc(&graph->cnt[gcnt_call_with_all_cnst_arg]);
+ if (num_local_adr > 0)
+ cnt_inc(&graph->cnt[gcnt_call_with_local_adr]);
+
+ stat_inc_int_distrib_tbl(status->dist_param_cnt, n);
+} /* analyse_params_of_Call */
/**
* Update info on calls.
ir_node *ptr = get_Call_ptr(call);
ir_entity *ent = NULL;
ir_graph *callee = NULL;
- int num_const_args;
/*
* If the block is bad, the whole subgraph will collapse later
} /* if */
} /* if */
- /* check, if arguments of the call are const */
- num_const_args = cnt_const_args(call);
-
- if (num_const_args > 0)
- cnt_inc(&graph->cnt[gcnt_call_with_cnst_arg]);
+ analyse_params_of_Call(graph, call);
} /* stat_update_call */
/**
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)) {
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);
*/
static void update_graph_stat_2(graph_entry_t *global, graph_entry_t *graph)
{
+ (void) global;
if (graph->is_deleted) {
/* deleted, ignore */
return;
} /* for */
} /* stat_dump_consts */
+/**
+ * Dumps the parameter distribution
+ */
+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_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.
*/
* @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;
* @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;
* @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;
/* do NOT count during dead node elimination */
- if (status->in_dead_node_elim > 0)
+ if (status->in_dead_node_elim)
return;
STAT_ENTER;
* @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;
* @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;
* 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;
*/
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;
*/
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;
ir_node **old_node_array, int old_num_entries,
hook_opt_kind opt)
{
+ (void) ctx;
if (! status->stat_options)
return;
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;
* @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;
* @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;
*/
static void stat_inline(void *ctx, ir_node *call, ir_graph *called_irg)
{
+ (void) ctx;
if (! status->stat_options)
return;
* @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;
* @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;
* @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;
- if (start)
- ++status->in_dead_node_elim;
- else
- --status->in_dead_node_elim;
+ status->in_dead_node_elim = (start != 0);
} /* stat_dead_node_elim */
/**
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;
*/
static void stat_func_call(void *context, ir_graph *irg, ir_node *call)
{
+ (void) context;
+ (void) call;
if (! status->stat_options)
return;
* @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;
* @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;
++p;
l = p - name;
- if (l > sizeof(fname) - 1)
+ if (l > (int) (sizeof(fname) - 1))
l = sizeof(fname) - 1;
memcpy(fname, name, l);
if (status->stat_options & FIRMSTAT_COUNT_CONSTS)
stat_dump_consts(&status->const_info);
+ /* 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);
if (enable_options & FIRMSTAT_COUNT_CONSTS)
stat_init_const_cnt(status);
+ /* distribution table for parameter counts */
+ status->dist_param_cnt = stat_new_int_distrib_tbl();
+
+ clear_optimization_counter();
+
#undef HOOK
#undef X
} /* firm_init_stat */
projects / libfirm / blobdiff