/*
- * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
+ * Copyright (C) 1995-2010 University of Karlsruhe. All right reserved.
*
* This file is part of libFirm.
*
* @file
* @brief Statistics for Firm.
* @author Michael Beck
- * @version $Id$
*/
#include "config.h"
-#ifdef FIRM_STATISTICS
-
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "xmalloc.h"
#include "irhooks.h"
#include "util.h"
+#include "ircons.h"
/*
* need this to be static:
/** The Div by Const node. */
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;
*/
static int opcode_cmp(const void *elt, const void *key)
{
- const node_entry_t *e1 = elt;
- const node_entry_t *e2 = key;
+ const node_entry_t *e1 = (const node_entry_t*)elt;
+ const node_entry_t *e2 = (const node_entry_t*)key;
return e1->op->code - e2->op->code;
} /* opcode_cmp */
*/
static int graph_cmp(const void *elt, const void *key)
{
- const graph_entry_t *e1 = elt;
- const graph_entry_t *e2 = key;
+ const graph_entry_t *e1 = (const graph_entry_t*)elt;
+ const graph_entry_t *e2 = (const graph_entry_t*)key;
return e1->irg != e2->irg;
} /* graph_cmp */
*/
static int opt_cmp(const void *elt, const void *key)
{
- const opt_entry_t *e1 = elt;
- const opt_entry_t *e2 = key;
+ const opt_entry_t *e1 = (const opt_entry_t*)elt;
+ const opt_entry_t *e2 = (const opt_entry_t*)key;
return e1->op->code != e2->op->code;
} /* opt_cmp */
*/
static int block_cmp(const void *elt, const void *key)
{
- const block_entry_t *e1 = elt;
- const block_entry_t *e2 = key;
+ const block_entry_t *e1 = (const block_entry_t*)elt;
+ const block_entry_t *e2 = (const block_entry_t*)key;
/* it's enough to compare the block number */
return e1->block_nr != e2->block_nr;
*/
static int be_block_cmp(const void *elt, const void *key)
{
- const be_block_entry_t *e1 = elt;
- const be_block_entry_t *e2 = key;
+ const be_block_entry_t *e1 = (const be_block_entry_t*)elt;
+ const be_block_entry_t *e2 = (const be_block_entry_t*)key;
return e1->block_nr != e2->block_nr;
} /* be_block_cmp */
*/
static int reg_pressure_cmp(const void *elt, const void *key)
{
- const reg_pressure_entry_t *e1 = elt;
- const reg_pressure_entry_t *e2 = key;
+ const reg_pressure_entry_t *e1 = (const reg_pressure_entry_t*)elt;
+ const reg_pressure_entry_t *e2 = (const reg_pressure_entry_t*)key;
return e1->class_name != e2->class_name;
} /* reg_pressure_cmp */
*/
static int perm_stat_cmp(const void *elt, const void *key)
{
- const perm_stat_entry_t *e1 = elt;
- const perm_stat_entry_t *e2 = key;
+ const perm_stat_entry_t *e1 = (const perm_stat_entry_t*)elt;
+ const perm_stat_entry_t *e2 = (const perm_stat_entry_t*)key;
return e1->perm != e2->perm;
} /* perm_stat_cmp */
*/
static int perm_class_cmp(const void *elt, const void *key)
{
- const perm_class_entry_t *e1 = elt;
- const perm_class_entry_t *e2 = key;
+ const perm_class_entry_t *e1 = (const perm_class_entry_t*)elt;
+ const perm_class_entry_t *e2 = (const perm_class_entry_t*)key;
return e1->class_name != e2->class_name;
} /* perm_class_cmp */
*/
static int opcode_cmp_2(const void *elt, const void *key)
{
- const ir_op *e1 = elt;
- const ir_op *e2 = key;
+ const ir_op *e1 = (const ir_op*)elt;
+ const ir_op *e2 = (const ir_op*)key;
return e1->code != e2->code;
} /* opcode_cmp_2 */
*/
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;
+ const address_mark_entry_t *e1 = (const address_mark_entry_t*)elt;
+ const address_mark_entry_t *e2 = (const address_mark_entry_t*)key;
(void) size;
/* compare only the nodes, the rest is used as data container */
key.op = op;
- elem = pset_find(hmap, &key, op->code);
+ elem = (node_entry_t*)pset_find(hmap, &key, op->code);
if (elem)
return elem;
elem->op = op;
- return pset_insert(hmap, elem, op->code);
+ return (node_entry_t*)pset_insert(hmap, elem, op->code);
} /* opcode_get_entry */
/**
ir_op key;
key.code = code;
- return pset_find(hmap, &key, code);
+ return (ir_op*)pset_find(hmap, &key, code);
} /* opcode_find_entry */
/**
key.irg = irg;
- elem = pset_find(hmap, &key, HASH_PTR(irg));
+ elem = (graph_entry_t*)pset_find(hmap, &key, hash_ptr(irg));
if (elem) {
/* create hash map backend block information */
elem->block_hash = NULL;
elem->extbb_hash = NULL;
- for (i = 0; i < sizeof(elem->opt_hash)/sizeof(elem->opt_hash[0]); ++i)
+ for (i = 0; i != ARRAY_SIZE(elem->opt_hash); ++i)
elem->opt_hash[i] = new_pset(opt_cmp, 4);
- return pset_insert(hmap, elem, HASH_PTR(irg));
+ return (graph_entry_t*)pset_insert(hmap, elem, hash_ptr(irg));
} /* graph_get_entry */
/**
key.op = op;
- elem = pset_find(hmap, &key, op->code);
+ elem = (opt_entry_t*)pset_find(hmap, &key, op->code);
if (elem)
return elem;
elem->op = op;
- return pset_insert(hmap, elem, op->code);
+ return (opt_entry_t*)pset_insert(hmap, elem, op->code);
} /* opt_get_entry */
/**
key.block_nr = block_nr;
- elem = pset_find(hmap, &key, block_nr);
+ elem = (block_entry_t*)pset_find(hmap, &key, block_nr);
if (elem)
return elem;
elem->block_nr = block_nr;
- return pset_insert(hmap, elem, block_nr);
+ return (block_entry_t*)pset_insert(hmap, elem, block_nr);
} /* block_get_entry */
/**
key.block_nr = block_nr;
- elem = pset_find(hmap, &key, block_nr);
+ elem = (be_block_entry_t*)pset_find(hmap, &key, block_nr);
if (elem)
return elem;
elem->block_nr = block_nr;
- return pset_insert(hmap, elem, block_nr);
+ return (be_block_entry_t*)pset_insert(hmap, elem, block_nr);
} /* be_block_get_entry */
/**
key.class_name = class_name;
- elem = pset_find(hmap, &key, HASH_PTR(class_name));
+ elem = (perm_class_entry_t*)pset_find(hmap, &key, hash_ptr(class_name));
if (elem)
return elem;
elem->class_name = class_name;
- return pset_insert(hmap, elem, HASH_PTR(class_name));
+ return (perm_class_entry_t*)pset_insert(hmap, elem, hash_ptr(class_name));
} /* perm_class_get_entry */
/**
key.perm = perm;
- elem = pset_find(hmap, &key, HASH_PTR(perm));
+ elem = (perm_stat_entry_t*)pset_find(hmap, &key, hash_ptr(perm));
if (elem)
return elem;
elem->perm = perm;
- return pset_insert(hmap, elem, HASH_PTR(perm));
+ return (perm_stat_entry_t*)pset_insert(hmap, elem, hash_ptr(perm));
} /* perm_stat_get_entry */
/**
static ir_op *stat_get_irn_op(ir_node *node)
{
ir_op *op = get_irn_op(node);
- ir_opcode opc = op->code;
+ unsigned opc = op->code;
switch (opc) {
case iro_Phi:
op = status->op_ModC ? status->op_ModC : op;
} /* if */
break;
- case iro_DivMod:
- 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 (is_Sel(get_Sel_ptr(node))) {
/* special case, a Sel of a Sel, count on extra counter */
} /* if */
break;
default:
- ;
+ break;
} /* switch */
return op;
*/
static void stat_update_address(ir_node *node, graph_entry_t *graph)
{
- ir_opcode opc = get_irn_opcode(node);
+ unsigned opc = get_irn_opcode(node);
ir_node *base;
ir_graph *irg;
case iro_Sel:
base = find_base_adr(node);
irg = current_ir_graph;
- if (base == get_irg_tls(irg)) {
- /* a TLS variable, like a global. */
- cnt_inc(&graph->cnt[gcnt_global_adr]);
- } else if (base == get_irg_frame(irg)) {
+ if (base == get_irg_frame(irg)) {
/* a local Variable. */
cnt_inc(&graph->cnt[gcnt_local_adr]);
} else {
} /* if */
} /* if */
default:
- ;
+ break;
} /* switch */
} /* stat_update_address */
*/
static void update_node_stat(ir_node *node, void *env)
{
- graph_entry_t *graph = env;
+ graph_entry_t *graph = (graph_entry_t*)env;
node_entry_t *entry;
ir_op *op = stat_get_irn_op(node);
}
}
default:
- ;
+ break;
} /* switch */
/* we want to count the constant IN nodes, not the CSE'ed constant's itself */
*/
static void update_node_stat_2(ir_node *node, void *env)
{
- graph_entry_t *graph = env;
+ graph_entry_t *graph = (graph_entry_t*)env;
/* check for properties that depends on calls like recursion/leaf/indirect call */
if (is_Call(node))
*/
static unsigned get_adr_mark(graph_entry_t *graph, ir_node *node)
{
- address_mark_entry_t *value = set_find(graph->address_mark, &node, sizeof(*value), HASH_PTR(node));
+ address_mark_entry_t *value = (address_mark_entry_t*)set_find(graph->address_mark, &node, sizeof(*value), hash_ptr(node));
return value ? value->mark : 0;
} /* get_adr_mark */
*/
static void set_adr_mark(graph_entry_t *graph, ir_node *node, unsigned val)
{
- address_mark_entry_t *value = set_insert(graph->address_mark, &node, sizeof(*value), HASH_PTR(node));
+ address_mark_entry_t *value = (address_mark_entry_t*)set_insert(graph->address_mark, &node, sizeof(*value), hash_ptr(node));
value->mark = val;
} /* set_adr_mark */
return get_Load_mode(node);
case iro_Store:
return get_irn_mode(get_Store_value(node));
- case iro_DivMod:
- return get_irn_mode(get_DivMod_left(node));
case iro_Div:
return get_irn_mode(get_Div_left(node));
case iro_Mod:
*/
static void mark_address_calc(ir_node *node, void *env)
{
- graph_entry_t *graph = env;
+ graph_entry_t *graph = (graph_entry_t*)env;
ir_mode *mode = get_irn_op_mode(node);
int i, n;
unsigned mark_preds = MARK_REF_NON_ADR;
*/
static void count_adr_ops(ir_node *node, void *env)
{
- graph_entry_t *graph = env;
+ graph_entry_t *graph = (graph_entry_t*)env;
unsigned mark = get_adr_mark(graph, node);
if (mark & MARK_ADDRESS_CALC)
int i;
/* clear first the alive counter in the graph */
- foreach_pset(graph->opcode_hash, entry) {
+ foreach_pset(graph->opcode_hash, node_entry_t*, entry) {
cnt_clr(&entry->cnt_alive);
} /* foreach_pset */
graph->is_chain_call = 0;
/* assume we walk every graph only ONCE, we could sum here the global count */
- foreach_pset(graph->opcode_hash, entry) {
+ foreach_pset(graph->opcode_hash, node_entry_t*, entry) {
node_entry_t *g_entry = opcode_get_entry(entry->op, global->opcode_hash);
/* update the node counter */
static void stat_register_dumper(const dumper_t *dumper)
{
dumper_t *p = XMALLOC(dumper_t);
-
- memcpy(p, dumper, sizeof(*p));
+ *p = *dumper;
p->next = status->dumper;
p->status = status;
if (dumper->func_map) {
dump_graph_FUNC func;
- foreach_pset(dumper->func_map, func)
+ foreach_pset(dumper->func_map, dump_graph_FUNC, func)
func(dumper, entry);
} /* if */
} /* for */
for (dumper = status->dumper; dumper; dumper = dumper->next) {
if (! dumper->func_map)
dumper->func_map = pset_new_ptr(3);
- pset_insert_ptr(dumper->func_map, func);
+ pset_insert_ptr(dumper->func_map, (void*)func);
} /* for */
} /* stat_register_dumper_func */
/*
* Helper: get an ir_op from an opcode.
*/
-ir_op *stat_get_op_from_opcode(ir_opcode code)
+ir_op *stat_get_op_from_opcode(unsigned code)
{
return opcode_find_entry(code, status->ir_op_hash);
} /* stat_get_op_from_opcode */
xopt = HOOK_OPT_CONFIRM_C;
} /* if */
- removed_due_opt(old_node_array[i], graph->opt_hash[xopt], xopt);
+ removed_due_opt(old_node_array[i], graph->opt_hash[xopt], (hook_opt_kind)xopt);
} /* if */
} /* for */
}
rp_ent->class_name = class_name;
rp_ent->pressure = pressure;
- pset_insert(block_ent->reg_pressure, rp_ent, HASH_PTR(class_name));
+ pset_insert(block_ent->reg_pressure, rp_ent, hash_ptr(class_name));
}
STAT_LEAVE;
} /* stat_be_block_regpressure */
{
char fname[2048];
const char *p;
- int l;
+ size_t l;
if (! status->stat_options)
return;
stat_dump_init(fname);
/* calculate the graph statistics */
- for (entry = pset_first(status->irg_hash); entry; entry = pset_next(status->irg_hash)) {
+ for (entry = (graph_entry_t*)pset_first(status->irg_hash);
+ entry != NULL; entry = (graph_entry_t*)pset_next(status->irg_hash)) {
if (entry->irg == NULL) {
/* special entry for the global count */
continue;
/* some calculations are dependent, we pushed them on the wait_q */
while (! pdeq_empty(status->wait_q)) {
- entry = pdeq_getr(status->wait_q);
+ entry = (graph_entry_t*)pdeq_getr(status->wait_q);
update_graph_stat_2(global, entry);
} /* while */
/* dump per graph */
- for (entry = pset_first(status->irg_hash); entry; entry = pset_next(status->irg_hash)) {
+ for (entry = (graph_entry_t*)pset_first(status->irg_hash);
+ entry != NULL; entry = (graph_entry_t*)pset_next(status->irg_hash)) {
if (entry->irg == NULL) {
/* special entry for the global count */
continue;
{
node_entry_t *entry;
- for (entry = pset_first(global->opcode_hash); entry; entry = pset_next(global->opcode_hash)) {
+ for (entry = (node_entry_t*)pset_first(global->opcode_hash);
+ entry != NULL; entry = (node_entry_t*)pset_next(global->opcode_hash)) {
opcode_clear_entry(entry);
} /* for */
/* clear all global counter */
STAT_LEAVE;
} /* stat_dump_snapshot */
-struct pass_t {
+typedef struct pass_t {
ir_prog_pass_t pass;
const char *fname;
const char *phase;
-};
+} pass_t;
/**
* 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;
+ pass_t *pass = (pass_t*)context;
(void)irp;
stat_dump_snapshot(pass->fname, pass->phase);
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);
+ pass_t *pass = XMALLOCZ(pass_t);
def_prog_pass_constructor(
&pass->pass, name ? name : "stat_snapshot", stat_dump_snapshot_wrapper);
_op_ModC.code = --num;
_op_ModC.name = new_id_from_chars(X("ModC"));
- _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;
status->op_MulC = &_op_MulC;
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;
status->op_MulC = NULL;
status->op_DivC = NULL;
status->op_ModC = NULL;
- status->op_DivModC = NULL;
- status->op_QuotC = NULL;
} /* if */
/* for Florian: count the Sel depth */
{
return status != (stat_info_t *)&status_disable;
} /* stat_is_active */
-
-#else
-
-/* initialize the statistics module. */
-void firm_init_stat(unsigned enable_options) {}
-
-/* Dumps a statistics snapshot */
-void stat_dump_snapshot(const char *name, const char *phase) {}
-
-/* terminates the statistics module, frees all memory */
-void stat_term(void);
-
-#endif /* FIRM_STATISTICS */