* @author Michael Beck
* @version $Id$
*/
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
+#include "config.h"
#include "stat_dmp.h"
#include "irtools.h"
#include "irhooks.h"
+#include "util.h"
/**
* names of the optimizations
{ HOOK_OPT_CONFIRM_C, "Confirm-based optimization: replaced by const" },
{ HOOK_OPT_CONFIRM_E, "Confirm-based optimization: evaluated" },
{ HOOK_OPT_EXC_REM, "a exception edge was removed due to a Confirmation prove" },
+ { HOOK_OPT_NORMALIZE, "a commutative node was normalized" },
{ HOOK_LOWERED, "Lowered" },
{ HOOK_BACKEND, "Backend transformation" },
{ FS_OPT_NEUTRAL_0, "algebraic simplification: a op 0 = 0 op a = a" },
{ FS_OPT_CONV, "algebraic simplification: Conv could be removed" },
{ FS_OPT_CAST, "algebraic simplification: a Cast could be removed" },
{ FS_OPT_MIN_MAX_EQ, "algebraic simplification: Min(a,a) = Max(a,a) = a" },
+ { FS_OPT_MUX_COMBINE, "boolean simplification: two Mux nodes where combined into one" },
+ { FS_OPT_MUX_CONV, "boolean simplification: MuxI(sel, 1, 0) = (I)sel" },
{ FS_OPT_MUX_BOOL, "boolean simplification: Muxb(sel, true, false) = sel" },
{ FS_OPT_MUX_NOT_BOOL, "boolean simplification: Muxb(sel, false, true) = Not(sel)" },
{ FS_OPT_MUX_OR_BOOL, "boolean simplification: Muxb(sel, true, x) = Or(sel, x)" },
{ FS_OPT_COMBO_CF, "Combo: removed conditional control flow" },
{ FS_OPT_COMBO_FOLLOWER, "Combo: removed a follower" },
{ FS_OPT_COMBO_CONGRUENT,"Combo: replaced by congruent" },
+ { FS_OPT_JUMPTHREADING, "Jump threading: removed conditional control flow" },
{ FS_OPT_RTS_ABS, "RTS optimization: call to abs() replaced" },
{ FS_OPT_RTS_ALLOCA, "RTS optimization: call to alloca() replaced" },
{ FS_OPT_RTS_SQRT, "RTS optimization: call to sqrt() replaced" },
{ FS_OPT_RTS_SYMMETRIC, "RTS optimization: call to symmetric function f(-x) replaced by f(x)" },
{ FS_OPT_RTS_STRCMP, "RTS optimization: call to strcmp() replaced" },
{ FS_OPT_RTS_STRNCMP, "RTS optimization: call to strncmp() replaced" },
+ { FS_OPT_RTS_STRCPY, "RTS optimization: call to strcpy() replaced" },
+ { FS_OPT_RTS_STRLEN, "RTS optimization: call to strlen() replaced" },
{ FS_OPT_RTS_MEMCPY, "RTS optimization: call to memcpy() replaced" },
+ { FS_OPT_RTS_MEMPCPY, "RTS optimization: call to mempcpy() replaced" },
+ { FS_OPT_RTS_MEMMOVE, "RTS optimization: call to memmove() replaced" },
{ FS_OPT_RTS_MEMSET, "RTS optimization: call to memset() replaced" },
- { FS_OPT_RTS_STRLEN, "RTS optimization: call to strlen() replaced" },
+ { FS_OPT_RTS_MEMCMP, "RTS optimization: call to memcmp() replaced" },
{ FS_BE_IA32_LEA, "ia32 Backend transformation: Lea was created" },
{ FS_BE_IA32_LOAD_LEA, "ia32 Backend transformation: Load merged with a Lea" },
{ FS_BE_IA32_STORE_LEA, "ia32 Backend transformation: Store merged with a Lea" },
counter_t f_alive;
counter_t f_new_node;
counter_t f_Id;
+ counter_t f_normlized;
cnt_clr(&f_alive);
cnt_clr(&f_new_node);
cnt_clr(&f_Id);
+ cnt_clr(&f_normlized);
- fprintf(dmp->f, "%-16s %-8s %-8s %-8s\n", "Opcode", "alive", "created", "->Id");
+ fprintf(dmp->f, "%-16s %-8s %-8s %-8s %-8s\n", "Opcode", "alive", "created", "->Id", "normalized");
foreach_pset(set, entry) {
- fprintf(dmp->f, "%-16s %8u %8u %8u\n",
+ fprintf(dmp->f, "%-16s %8u %8u %8u %8u\n",
get_id_str(entry->op->name),
cnt_to_uint(&entry->cnt_alive),
cnt_to_uint(&entry->new_node),
- cnt_to_uint(&entry->into_Id)
+ cnt_to_uint(&entry->into_Id),
+ cnt_to_uint(&entry->normalized)
);
- cnt_add(&f_alive, &entry->cnt_alive);
- cnt_add(&f_new_node, &entry->new_node);
- cnt_add(&f_Id, &entry->into_Id);
+ cnt_add(&f_alive, &entry->cnt_alive);
+ cnt_add(&f_new_node, &entry->new_node);
+ cnt_add(&f_Id, &entry->into_Id);
+ cnt_add(&f_normlized, &entry->normalized);
} /* foreach_pset */
fprintf(dmp->f, "-------------------------------------------\n");
- fprintf(dmp->f, "%-16s %8u %8u %8u\n", "Sum",
+ fprintf(dmp->f, "%-16s %8u %8u %8u %8u\n", "Sum",
cnt_to_uint(&f_alive),
cnt_to_uint(&f_new_node),
- cnt_to_uint(&f_Id)
+ cnt_to_uint(&f_Id),
+ cnt_to_uint(&f_normlized)
);
} /* simple_dump_opcode_hash */
/**
* Return the name of an optimization.
*/
-static const char *get_opt_name(int index) {
- assert(index < (int) ARR_SIZE(opt_names) && "index out of range");
+static const char *get_opt_name(int index)
+{
+ assert(index < (int) ARRAY_SIZE(opt_names) && "index out of range");
assert((int) opt_names[index].kind == index && "opt_names broken");
return opt_names[index].name;
} /* get_opt_name */
} /* 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)
+{
dumper_t *dmp = env;
- fprintf(dmp->f, "%12d", cnt_to_uint(&entry->cnt));
+ fprintf(dmp->f, "%12u", cnt_to_uint(&entry->cnt));
} /* simple_dump_distrib_entry */
/**
/**
* Adds the counter for given entry to another distribution table.
*/
-static void add_distrib_entry(const distrib_entry_t *entry, void *env) {
+static void add_distrib_entry(const distrib_entry_t *entry, void *env)
+{
distrib_tbl_t *sum_tbl = env;
stat_add_int_distrib_tbl(sum_tbl, PTR_TO_INT(entry->object), &entry->cnt);
if (! dmp->f)
return;
- fprintf(dmp->f, "%-16s %8d\n", "Edges", cnt_to_uint(cnt));
+ fprintf(dmp->f, "%-16s %8u\n", "Edges", cnt_to_uint(cnt));
} /* simple_dump_edges */
/**
fprintf(dmp->f, "\nBit usage for integer constants\n");
fprintf(dmp->f, "-------------------------------\n");
- for (i = 0; i < ARR_SIZE(tbl->int_bits_count); ++i) {
+ for (i = 0; i < ARRAY_SIZE(tbl->int_bits_count); ++i) {
fprintf(dmp->f, "%5u %12u\n", (unsigned) (i + 1), cnt_to_uint(&tbl->int_bits_count[i]));
cnt_add(&sum, &tbl->int_bits_count[i]);
} /* for */
fprintf(dmp->f, "\nFloating point constants classification\n");
fprintf(dmp->f, "--------------------------------------\n");
- for (i = 0; i < ARR_SIZE(tbl->floats); ++i) {
+ for (i = 0; i < ARRAY_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 */
/**
* Dumps a line of the parameter table
*/
-static void dump_tbl_line(const distrib_entry_t *entry, void *env) {
+static void dump_tbl_line(const distrib_entry_t *entry, void *env)
+{
dumper_t *dmp = env;
fprintf(dmp->f, "%d : %u\n", PTR_TO_INT(entry->object), cnt_to_uint(&entry->cnt));
/**
* dumps the parameter distribution table
*/
-static void simple_dump_param_tbl(dumper_t *dmp, const distrib_tbl_t *tbl, graph_entry_t *global) {
+static void simple_dump_param_tbl(dumper_t *dmp, const distrib_tbl_t *tbl, graph_entry_t *global)
+{
fprintf(dmp->f, "\nCall parameter Information:\n");
fprintf(dmp->f, "---------------------\n");
/**
* dumps the optimization counter table
*/
-static void simple_dump_opt_cnt(dumper_t *dmp, const counter_t *tbl, unsigned len) {
+static void simple_dump_opt_cnt(dumper_t *dmp, const counter_t *tbl, unsigned len)
+{
unsigned i;
fprintf(dmp->f, "\nOptimization counts:\n");
/**
* 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);
/**
* 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;
csv_count_nodes(dmp, entry, cnt);
- fprintf(dmp->f, "%-40s, %p, %d, %d, %d, %d\n",
+ fprintf(dmp->f, "%-40s, %p, %u, %u, %u, %u\n",
name,
(void *)entry->irg,
cnt_to_uint(&cnt[0]),
/**
* dumps the parameter distribution table
*/
-static void csv_dump_param_tbl(dumper_t *dmp, const distrib_tbl_t *tbl, graph_entry_t *global) {
+static void csv_dump_param_tbl(dumper_t *dmp, const distrib_tbl_t *tbl, graph_entry_t *global)
+{
(void) dmp;
(void) tbl;
(void) global;
/**
* dumps the optimization counter
*/
-static void csv_dump_opt_cnt(dumper_t *dmp, const counter_t *tbl, unsigned len) {
+static void csv_dump_opt_cnt(dumper_t *dmp, const counter_t *tbl, unsigned len)
+{
(void) dmp;
(void) tbl;
(void) len;