/*
- * 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.
*
/** 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;
/* ---------------------------------------------------------------------------------- */
/** Marks the begin of a statistic (hook) function. */
-#define STAT_ENTER ++status->recursive
+#define STAT_ENTER ++status->recursive
/** Marks the end of a statistic (hook) functions. */
-#define STAT_LEAVE --status->recursive
+#define STAT_LEAVE --status->recursive
/** Allows to enter a statistic function only when we are not already in a hook. */
-#define STAT_ENTER_SINGLE do { if (status->recursive > 0) return; ++status->recursive; } while (0)
+#define STAT_ENTER_SINGLE do { if (status->recursive > 0) return; ++status->recursive; } while (0)
/**
* global status
*/
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 */
for (i = 0; i < sizeof(elem->opt_hash)/sizeof(elem->opt_hash[0]); ++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 */
ir_node *other_block = get_nodes_block(pred);
block_entry_t *b_entry_other = block_get_entry(&graph->recalc_cnts, get_irn_node_nr(other_block), graph->block_hash);
- cnt_inc(&b_entry->cnt[bcnt_in_edges]); /* an edge coming from another block */
+ cnt_inc(&b_entry->cnt[bcnt_in_edges]); /* an edge coming from another block */
cnt_inc(&b_entry_other->cnt[bcnt_out_edges]);
} /* for */
return;
other_block = get_nodes_block(pred);
if (other_block == block)
- cnt_inc(&b_entry->cnt[bcnt_edges]); /* a in block edge */
+ cnt_inc(&b_entry->cnt[bcnt_edges]); /* a in block edge */
else {
block_entry_t *b_entry_other = block_get_entry(&graph->recalc_cnts, get_irn_node_nr(other_block), graph->block_hash);
- cnt_inc(&b_entry->cnt[bcnt_in_edges]); /* an edge coming from another block */
+ cnt_inc(&b_entry->cnt[bcnt_in_edges]); /* an edge coming from another block */
cnt_inc(&b_entry_other->cnt[bcnt_out_edges]);
} /* if */
} /* for */
if (extbb != other_extbb) {
extbb_entry_t *eb_entry_other = block_get_entry(&graph->recalc_cnts, get_extbb_node_nr(other_extbb), graph->extbb_hash);
- cnt_inc(&eb_entry->cnt[bcnt_in_edges]); /* an edge coming from another extbb */
+ cnt_inc(&eb_entry->cnt[bcnt_in_edges]); /* an edge coming from another extbb */
cnt_inc(&eb_entry_other->cnt[bcnt_out_edges]);
} /* if */
} /* for */
ir_extblk *other_extbb = get_nodes_extbb(pred);
if (other_extbb == extbb)
- cnt_inc(&eb_entry->cnt[bcnt_edges]); /* a in extbb edge */
+ cnt_inc(&eb_entry->cnt[bcnt_edges]); /* a in extbb edge */
else {
extbb_entry_t *eb_entry_other = block_get_entry(&graph->recalc_cnts, get_extbb_node_nr(other_extbb), graph->extbb_hash);
- cnt_inc(&eb_entry->cnt[bcnt_in_edges]); /* an edge coming from another extbb */
+ cnt_inc(&eb_entry->cnt[bcnt_in_edges]); /* an edge coming from another extbb */
cnt_inc(&eb_entry_other->cnt[bcnt_out_edges]);
} /* if */
} /* for */
for (; curr != block && get_Block_dom_depth(curr) > depth;) {
curr = get_Block_idom(curr);
- if (! curr || is_no_Block(curr))
+ if (! curr || !is_Block(curr))
break;
} /* for */
*/
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 */
/* other parameter */
cnt_inc(&graph->cnt[gcnt_param_adr]);
-end_parameter: ;
+end_parameter: ;
} else {
/* unknown Pointer access */
cnt_inc(&graph->cnt[gcnt_other_adr]);
*/
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);
*/
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 */
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 */
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 */
}
{
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 */
projects / libfirm / blobdiff