cnt_add(&f_alive, &entry->cnt_alive);
cnt_add(&f_new_node, &entry->new_node);
cnt_add(&f_Id, &entry->into_Id);
- }
+ } /* foreach_pset */
fprintf(dmp->f, "-------------------------------------------\n");
fprintf(dmp->f, "%-16s %8u %8u %8u\n", "Sum",
cnt_to_uint(&f_alive),
cnt_to_uint(&f_new_node),
cnt_to_uint(&f_Id)
);
-}
+} /* simple_dump_opcode_hash */
/**
* dumps an optimization hash into human readable form
foreach_pset(set, entry) {
fprintf(dmp->f, "%-16s %8u\n",
get_id_str(entry->op->name), cnt_to_uint(&entry->count));
- }
- }
-}
+ } /* foreach_pset */
+ } /* if */
+} /* simple_dump_opt_hash */
/**
* dumps the register pressure for each block and for each register class
foreach_pset(b_entry->reg_pressure, rp_entry)
fprintf(dmp->f, "%15d", rp_entry->pressure);
fprintf(dmp->f, "\n");
- }
-}
+ } /* for */
+} /* simple_dump_be_block_reg_pressure */
/** prints a distribution entry */
-static void simple_dump_distrib_entry(const distrib_entry_t *entry, void *env)
-{
+static void simple_dump_distrib_entry(const distrib_entry_t *entry, void *env) {
FILE *dmp_f = env;
fprintf(dmp_f, "%12d", cnt_to_uint(&entry->cnt));
-}
+} /* simple_dump_distrib_entry */
/**
* dumps the distribution of the amount of ready nodes for each block
stat_iterate_distrib_tbl(b_entry->sched_ready, simple_dump_distrib_entry, dmp->f);
fprintf(dmp->f, "%12.2lf", stat_calc_avg_distrib_tbl(b_entry->sched_ready));
fprintf(dmp->f, "\n");
- }
- }
-}
+ } /* foreach_pset */
+ } /* if */
+} /* simple_dump_be_block_sched_ready */
/**
* Adds the counter for given entry to another distribution table.
distrib_tbl_t *sum_tbl = env;
stat_add_int_distrib_tbl(sum_tbl, (int)(entry->object), &entry->cnt);
-}
+} /* add_distrib_entry */
/**
* dumps permutation statistics for one and block and one class
/* sum up distribution table for cycles */
stat_iterate_distrib_tbl(ps_ent->cycles, add_distrib_entry, sum_cycles);
- }
+ } /* foreach_pset */
/* print chain distribution for all perms of this class in this block */
fprintf(dmp->f, "chain distribution:\n");
snprintf(buf, sizeof(buf), "length %d", i);
fprintf(dmp->f, "%12s", buf);
stat_insert_int_distrib_tbl(sum_chains, i);
- }
+ } /* for */
fprintf(dmp->f, "\n");
stat_iterate_distrib_tbl(sum_chains, simple_dump_distrib_entry, dmp->f);
fprintf(dmp->f, "\n");
snprintf(buf, sizeof(buf), "length %d", i);
fprintf(dmp->f, "%12s", buf);
stat_insert_int_distrib_tbl(sum_cycles, i);
- }
+ } /* for */
fprintf(dmp->f, "\n");
stat_iterate_distrib_tbl(sum_cycles, simple_dump_distrib_entry, dmp->f);
fprintf(dmp->f, "\n");
stat_delete_distrib_tbl(sum_chains);
stat_delete_distrib_tbl(sum_cycles);
-}
+} /* simple_dump_be_block_permstat_class */
/**
* dumps statistics about perms
fprintf(dmp->f, "BLOCK %ld:\n", b_entry->block_nr);
- if (b_entry->perm_class_stat)
+ if (b_entry->perm_class_stat) {
foreach_pset(b_entry->perm_class_stat, pc_ent) {
fprintf(dmp->f, "register class %s:\n", pc_ent->class_name);
simple_dump_be_block_permstat_class(dmp, pc_ent);
- }
- }
+ } /* foreach_pset */
+ } /* if */
+ } /* foreach_pset */
fprintf(dmp->f, "PERMUTATION STATISTICS END\n");
- }
-}
+ } /* if */
+} /* simple_dump_be_block_permstat */
/**
* dumps the number of real_function_call optimization
if (! cnt_eq(cnt, 0)) {
fprintf(dmp->f, "\nReal Function Calls optimized:\n");
fprintf(dmp->f, "%-16s %8u\n", "Call", cnt_to_uint(cnt));
- }
-}
+ } /* if */
+} /* simple_dump_real_func_calls */
/**
* dumps the number of tail_recursion optimization
if (num_tail_recursion > 0) {
fprintf(dmp->f, "\nTail recursion optimized:\n");
fprintf(dmp->f, "%-16s %8u\n", "Call", num_tail_recursion);
- }
-}
+ } /* if */
+} /* simple_dump_tail_recursion */
/**
* dumps the edges count
return;
fprintf(dmp->f, "%-16s %8d\n", "Edges", cnt_to_uint(cnt));
-}
+} /* simple_dump_edges */
/**
* dumps the IRG
fprintf(dmp->f, "\nEntity %s, Irg %p", get_entity_ld_name(entry->ent), (void *)entry->irg);
else
fprintf(dmp->f, "\nIrg %p", (void *)entry->irg);
- }
+ } /* if */
fprintf(dmp->f, " %swalked %u over blocks %u:\n"
" was inlined : %u\n"
for (i = 0; i < sizeof(entry->cnt_if_conv)/sizeof(entry->cnt_if_conv[0]); ++i) {
fprintf(dmp->f, " %s : %u\n", if_conv_names[i], cnt_to_uint(&entry->cnt_if_conv[i]));
- }
- }
- else {
+ } /* for */
+ } else {
fprintf(dmp->f, "\nGlobals counts:\n");
fprintf(dmp->f, "--------------\n");
dump_opts = 0;
- }
+ } /* if */
+
+ /* address ops */
+ fprintf(dmp->f,
+ " pure address calc ops : %u\n"
+ " all address calc ops : %u\n",
+ cnt_to_uint(&entry->cnt_pure_adr_ops),
+ cnt_to_uint(&entry->cnt_all_adr_ops));
simple_dump_opcode_hash(dmp, entry->opcode_hash);
simple_dump_edges(dmp, &entry->cnt_edges);
for (i = 0; i < sizeof(entry->opt_hash)/sizeof(entry->opt_hash[0]); ++i) {
simple_dump_opt_hash(dmp, entry->opt_hash[i], i);
- }
+ } /* for */
/* dump block info */
fprintf(dmp->f, "\n%12s %12s %12s %12s %12s %12s %12s\n", "Block Nr", "Nodes", "intern E", "incoming E", "outgoing E", "Phi", "quot");
cnt_to_uint(&b_entry->cnt_phi_data),
cnt_to_dbl(&b_entry->cnt_edges) / cnt_to_dbl(&b_entry->cnt_nodes)
);
- }
+ } /* foreach_pset */
/* dump block reg pressure */
simple_dump_be_block_reg_pressure(dmp, entry);
cnt_to_uint(&eb_entry->cnt_phi_data),
cnt_to_dbl(&eb_entry->cnt_edges) / cnt_to_dbl(&eb_entry->cnt_nodes)
);
- }
- }
+ } /* foreach_pset */
+ } /* if */
}
-}
+} /* simple_dump_graph */
/**
- * dumps the IRG
+ * dumps the constant table
*/
static void simple_dump_const_tbl(dumper_t *dmp, const constant_info_t *tbl)
{
for (i = 0; i < ARR_SIZE(tbl->int_bits_count); ++i) {
fprintf(dmp->f, "%5d %12u\n", i + 1, cnt_to_uint(&tbl->int_bits_count[i]));
cnt_add(&sum, &tbl->int_bits_count[i]);
- }
+ } /* for */
fprintf(dmp->f, "-------------------------------\n");
fprintf(dmp->f, "\nFloating point constants classification\n");
for (i = 0; i < ARR_SIZE(tbl->floats); ++i) {
fprintf(dmp->f, "%-10s %12u\n", stat_fc_name(i), cnt_to_uint(&tbl->floats[i]));
cnt_add(&sum, &tbl->floats[i]);
- }
+ } /* for */
fprintf(dmp->f, "--------------------------------------\n");
fprintf(dmp->f, "other %12u\n", cnt_to_uint(&tbl->others));
fprintf(dmp->f, "-------------------------------\n");
fprintf(dmp->f, "sum %12u\n", cnt_to_uint(&sum));
-}
+} /* simple_dump_const_tbl */
/**
* initialize the simple dumper
*/
-static void simple_init(dumper_t *dmp, const char *name)
-{
+static void simple_init(dumper_t *dmp, const char *name) {
char fname[2048];
snprintf(fname, sizeof(fname), "%s.txt", name);
dmp->f = fopen(fname, "w");
if (! dmp->f) {
perror(fname);
- }
-}
+ } /* if */
+} /* simple_init */
/**
* finishes the simple dumper
*/
-static void simple_finish(dumper_t *dmp)
-{
+static void simple_finish(dumper_t *dmp) {
if (dmp->f)
fclose(dmp->f);
dmp->f = NULL;
-}
+} /* simple_finish */
/**
* the simple human readable dumper
if (entry->op == op_Phi) {
/* normal Phi */
cnt_add(&cnt[1], &entry->cnt_alive);
- }
- else if (entry->op == dmp->status->op_PhiM) {
+ } else if (entry->op == dmp->status->op_PhiM) {
/* memory Phi */
cnt_add(&cnt[2], &entry->cnt_alive);
- }
- else if (entry->op == op_Proj) {
+ } else if (entry->op == op_Proj) {
/* Proj */
cnt_add(&cnt[3], &entry->cnt_alive);
- }
- else {
+ } else {
/* all other nodes */
cnt_add(&cnt[0], &entry->cnt_alive);
- }
- }
-}
+ } /* if */
+ } /* foreach_pset */
+} /* csv_count_nodes */
/**
* dumps the IRG
if (entry->irg == const_irg) {
name = "<Const code Irg>";
return;
- }
- else {
+ } else {
if (entry->ent)
name = get_entity_name(entry->ent);
else
name = "<UNKNOWN IRG>";
- }
+ } /* if */
csv_count_nodes(dmp, entry, cnt);
cnt_to_uint(&cnt[2]),
cnt_to_uint(&cnt[3])
);
- }
-}
+ } /* if */
+} /* csv_dump_graph */
/**
* dumps the IRG
static void csv_dump_const_tbl(dumper_t *dmp, const constant_info_t *tbl)
{
/* FIXME: NYI */
-}
+} /* csv_dump_const_tbl */
/**
* initialize the simple dumper
dmp->f = fopen(fname, "a");
if (! dmp->f)
perror(fname);
-}
+} /* csv_init */
/**
* finishes the simple dumper
if (dmp->f)
fclose(dmp->f);
dmp->f = NULL;
-}
+} /* csv_finish */
/**
* the simple human readable dumper