X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fstat%2Fstat_dmp.c;h=fd71cca007ef76d5167c5fad41551f3d230a60fe;hb=2cc9db25f1d7780e24013ef1cc912a3cd770d7a5;hp=6caaa3313a3eb411ea5db7a5a6ec7c72473cb0a6;hpb=cc6c81cfca9c224e26bf8033fd6dad1158546502;p=libfirm

diff --git a/ir/stat/stat_dmp.c b/ir/stat/stat_dmp.c
index 6caaa3313..fd71cca00 100644
--- a/ir/stat/stat_dmp.c
+++ b/ir/stat/stat_dmp.c
@@ -1,12 +1,27 @@
 /*
- * Project:     libFIRM
- * File name:   ir/ir/stat_dmp.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-2007 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. Dumping.
+ * @author  Michael Beck
+ * @version $Id$
  */
 #ifdef HAVE_CONFIG_H
 # include "config.h"
@@ -57,6 +72,7 @@ static const struct {
 	{ FS_OPT_ADD_MUL_A_X_A,  "algebraic simplification: a * x + a = a * (x + 1)" },
 	{ FS_OPT_SUB_0_A,        "algebraic simplification: 0 - a = -a" },
 	{ FS_OPT_SUB_MUL_A_X_A,  "algebraic simplification: a * x - a = a * (x - 1)" },
+	{ FS_OPT_SUB_SUB_X_Y_Z,  "algebraic simplification: (x - y) - z = x - (y + z)" },
 	{ FS_OPT_MUL_MINUS_1,    "algebraic simplification: a * -1 = -a" },
 	{ FS_OPT_OR,             "algebraic simplification: a | a = a | 0 = 0 | a = a" },
 	{ FS_OPT_AND,            "algebraic simplification: a & 0b1...1 = 0b1...1 & a =  a & a = a" },
@@ -76,6 +92,7 @@ static const struct {
 	{ FS_OPT_MUX_TO_MAX,     "algebraic simplification: Mux(a > b, a, b) = Max(a,b)" },
 	{ FS_OPT_MUX_TO_ABS,     "algebraic simplification: Mux(a > b, a, b) = Abs(a,b)" },
 	{ FS_OPT_MUX_TO_SHR,     "algebraic simplification: Mux(a > b, a, b) = a >> b" },
+	{ FS_OPT_CONST_PHI,      "constant evaluation on Phi node" },
 	{ 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" },
@@ -124,14 +141,14 @@ static void simple_dump_opcode_hash(dumper_t *dmp, pset *set)
 		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
@@ -150,9 +167,9 @@ static void simple_dump_opt_hash(dumper_t *dmp, pset *set, int index)
 		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
@@ -183,15 +200,14 @@ static void simple_dump_be_block_reg_pressure(dumper_t *dmp, graph_entry_t *entr
 		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 */
-void dump_block_sched_ready_distrib(const distrib_entry_t *entry, void *env)
-{
-	FILE *dmp_f = env;
-	fprintf(dmp_f, "%12d", cnt_to_uint(&entry->cnt));
-}
+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));
+}  /* simple_dump_distrib_entry */
 
 /**
  * dumps the distribution of the amount of ready nodes for each block
@@ -212,12 +228,21 @@ static void simple_dump_be_block_sched_ready(dumper_t *dmp, graph_entry_t *entry
 				stat_insert_int_distrib_tbl(b_entry->sched_ready, i);
 
 			fprintf(dmp->f, "BLK   %6ld", b_entry->block_nr);
-			stat_iterate_distrib_tbl(b_entry->sched_ready, dump_block_sched_ready_distrib, dmp->f);
+			stat_iterate_distrib_tbl(b_entry->sched_ready, simple_dump_distrib_entry, dmp);
 			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.
+ */
+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, (int)(entry->object), &entry->cnt);
+}  /* add_distrib_entry */
 
 /**
  * dumps permutation statistics for one and block and one class
@@ -225,17 +250,68 @@ static void simple_dump_be_block_sched_ready(dumper_t *dmp, graph_entry_t *entry
 static void simple_dump_be_block_permstat_class(dumper_t *dmp, perm_class_entry_t *entry)
 {
 	perm_stat_entry_t *ps_ent;
+	distrib_tbl_t     *sum_chains = stat_new_int_distrib_tbl();
+	distrib_tbl_t     *sum_cycles = stat_new_int_distrib_tbl();
+	char              buf[16];
+	int               i;
+
+	fprintf(dmp->f, "%12s %12s %12s %12s %12s %12s\n",
+		"size",
+		"real size",
+		"# chains",
+		"# cycles",
+		"# copies",
+		"# exchanges"
+	);
 
-	fprintf(dmp->f, "%12s %12s %12s %12s\n", "size", "real size", "# chains", "# cycles");
 	foreach_pset(entry->perm_stat, ps_ent) {
-		fprintf(dmp->f, "%12d %12d %12d %12d\n",
+		fprintf(dmp->f, "%12d %12d %12d %12d %12d %12d\n",
 			ps_ent->size,
 			ps_ent->real_size,
 			stat_get_count_distrib_tbl(ps_ent->chains),
-			stat_get_count_distrib_tbl(ps_ent->cycles)
+			stat_get_count_distrib_tbl(ps_ent->cycles),
+			ps_ent->n_copies,
+			ps_ent->n_exchg
 		);
-	}
-}
+
+		/* sum up distribution table for chains */
+		stat_iterate_distrib_tbl(ps_ent->chains, add_distrib_entry, sum_chains);
+
+		/* 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");
+
+	/* add all missing entries to chain distribution table */
+	for (i = 1; i <= entry->n_regs; i++) {
+		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");
+
+	/* print cycle distribution for all perms of this class in this block */
+	fprintf(dmp->f, "cycle distribution:\n");
+
+	/* add all missing entries to cycle distribution table */
+	for (i = 1; i <= entry->n_regs; i++) {
+		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");
+
+	/* delete temporary sum distribution tables */
+	stat_delete_distrib_tbl(sum_chains);
+	stat_delete_distrib_tbl(sum_cycles);
+
+}  /* simple_dump_be_block_permstat_class */
 
 /**
  * dumps statistics about perms
@@ -251,16 +327,17 @@ static void simple_dump_be_block_permstat(dumper_t *dmp, graph_entry_t *entry)
 
 			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
@@ -273,8 +350,8 @@ static void simple_dump_real_func_calls(dumper_t *dmp, counter_t *cnt)
 	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
@@ -287,8 +364,8 @@ static void simple_dump_tail_recursion(dumper_t *dmp, unsigned num_tail_recursio
 	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
@@ -299,7 +376,7 @@ static void simple_dump_edges(dumper_t *dmp, counter_t *cnt)
 		return;
 
 	fprintf(dmp->f, "%-16s %8d\n", "Edges", cnt_to_uint(cnt));
-}
+}  /* simple_dump_edges */
 
 /**
  * dumps the IRG
@@ -323,7 +400,7 @@ static void simple_dump_graph(dumper_t *dmp, graph_entry_t *entry)
 				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"
@@ -336,55 +413,76 @@ static void simple_dump_graph(dumper_t *dmp, graph_entry_t *entry)
 			" calls                     : %u\n"
 			" indirect calls            : %u\n",
 			entry->is_deleted ? "DELETED " : "",
-			cnt_to_uint(&entry->cnt_walked), cnt_to_uint(&entry->cnt_walked_blocks),
-			cnt_to_uint(&entry->cnt_was_inlined),
-			cnt_to_uint(&entry->cnt_got_inlined),
-			cnt_to_uint(&entry->cnt_strength_red),
+			cnt_to_uint(&entry->cnt[gcnt_acc_walked]), cnt_to_uint(&entry->cnt[gcnt_acc_walked_blocks]),
+			cnt_to_uint(&entry->cnt[gcnt_acc_was_inlined]),
+			cnt_to_uint(&entry->cnt[gcnt_acc_got_inlined]),
+			cnt_to_uint(&entry->cnt[gcnt_acc_strength_red]),
 			entry->is_leaf ? "YES" : "NO",
 			entry->is_leaf_call == LCS_NON_LEAF_CALL ? "NO" : (entry->is_leaf_call == LCS_LEAF_CALL ? "Yes" : "Maybe"),
 			entry->is_recursive ? "YES" : "NO",
 			entry->is_chain_call ? "YES" : "NO",
-			cnt_to_uint(&entry->cnt_all_calls),
-			cnt_to_uint(&entry->cnt_indirect_calls)
+			cnt_to_uint(&entry->cnt[gcnt_all_calls]),
+			cnt_to_uint(&entry->cnt[gcnt_indirect_calls])
 		);
 
-		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 (i = 0; i < IF_RESULT_LAST; ++i) {
+			fprintf(dmp->f, " %s : %u\n", if_conv_names[i], cnt_to_uint(&entry->cnt[gcnt_if_conv + i]));
+		}  /* 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[gcnt_pure_adr_ops]),
+		cnt_to_uint(&entry->cnt[gcnt_all_adr_ops])
+	);
+
+	/* Load/Store address classification */
+	fprintf(dmp->f,
+		" global Ld/St address      : %u\n"
+		" local Ld/St address       : %u\n"
+		" this Ld/St address        : %u\n"
+		" param Ld/St address       : %u\n"
+		" other Ld/St address       : %u\n",
+		cnt_to_uint(&entry->cnt[gcnt_global_adr]),
+		cnt_to_uint(&entry->cnt[gcnt_local_adr]),
+		cnt_to_uint(&entry->cnt[gcnt_this_adr]),
+		cnt_to_uint(&entry->cnt[gcnt_param_adr]),
+		cnt_to_uint(&entry->cnt[gcnt_other_adr])
+	);
 
 	simple_dump_opcode_hash(dmp, entry->opcode_hash);
-	simple_dump_edges(dmp, &entry->cnt_edges);
+	simple_dump_edges(dmp, &entry->cnt[gcnt_edges]);
 
 	/* effects of optimizations */
 	if (dump_opts) {
 		int i;
 
-		simple_dump_real_func_calls(dmp, &entry->cnt_real_func_call);
+		simple_dump_real_func_calls(dmp, &entry->cnt[gcnt_acc_real_func_call]);
 		simple_dump_tail_recursion(dmp, entry->num_tail_recursion);
 
 		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");
 		foreach_pset(entry->block_hash, b_entry) {
 			fprintf(dmp->f, "BLK   %6ld %12u %12u %12u %12u %12u %4.8f\n",
 				b_entry->block_nr,
-				cnt_to_uint(&b_entry->cnt_nodes),
-				cnt_to_uint(&b_entry->cnt_edges),
-				cnt_to_uint(&b_entry->cnt_in_edges),
-				cnt_to_uint(&b_entry->cnt_out_edges),
-				cnt_to_uint(&b_entry->cnt_phi_data),
-				cnt_to_dbl(&b_entry->cnt_edges) / cnt_to_dbl(&b_entry->cnt_nodes)
+				cnt_to_uint(&b_entry->cnt[bcnt_nodes]),
+				cnt_to_uint(&b_entry->cnt[bcnt_edges]),
+				cnt_to_uint(&b_entry->cnt[bcnt_in_edges]),
+				cnt_to_uint(&b_entry->cnt[bcnt_out_edges]),
+				cnt_to_uint(&b_entry->cnt[bcnt_phi_data]),
+				cnt_to_dbl(&b_entry->cnt[bcnt_edges]) / cnt_to_dbl(&b_entry->cnt[bcnt_nodes])
 			);
-		}
+		}  /* foreach_pset */
 
 		/* dump block reg pressure */
 		simple_dump_be_block_reg_pressure(dmp, entry);
@@ -395,26 +493,26 @@ static void simple_dump_graph(dumper_t *dmp, graph_entry_t *entry)
 		/* dump block permutation statistics */
 		simple_dump_be_block_permstat(dmp, entry);
 
-		if (dmp->status->stat_options & FIRMSTAT_COUNT_EXTBB) {
+		if (dmp->status->stat_options & FIRMSTAT_COUNT_EXTBB && entry->extbb_hash) {
 			/* dump extended block info */
 			fprintf(dmp->f, "\n%12s %12s %12s %12s %12s %12s %12s\n", "Extbb Nr", "Nodes", "intern E", "incoming E", "outgoing E", "Phi", "quot");
 			foreach_pset(entry->extbb_hash, eb_entry) {
 				fprintf(dmp->f, "ExtBB %6ld %12u %12u %12u %12u %12u %4.8f\n",
 					eb_entry->block_nr,
-					cnt_to_uint(&eb_entry->cnt_nodes),
-					cnt_to_uint(&eb_entry->cnt_edges),
-					cnt_to_uint(&eb_entry->cnt_in_edges),
-					cnt_to_uint(&eb_entry->cnt_out_edges),
-					cnt_to_uint(&eb_entry->cnt_phi_data),
-					cnt_to_dbl(&eb_entry->cnt_edges) / cnt_to_dbl(&eb_entry->cnt_nodes)
+					cnt_to_uint(&eb_entry->cnt[bcnt_nodes]),
+					cnt_to_uint(&eb_entry->cnt[bcnt_edges]),
+					cnt_to_uint(&eb_entry->cnt[bcnt_in_edges]),
+					cnt_to_uint(&eb_entry->cnt[bcnt_out_edges]),
+					cnt_to_uint(&eb_entry->cnt[bcnt_phi_data]),
+					cnt_to_dbl(&eb_entry->cnt[bcnt_edges]) / cnt_to_dbl(&eb_entry->cnt[bcnt_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)
 {
@@ -435,7 +533,7 @@ 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");
@@ -443,7 +541,7 @@ static void simple_dump_const_tbl(dumper_t *dmp, const constant_info_t *tbl)
 	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));
@@ -451,31 +549,54 @@ static void simple_dump_const_tbl(dumper_t *dmp, const constant_info_t *tbl)
 	fprintf(dmp->f, "-------------------------------\n");
 
 	fprintf(dmp->f, "sum   %12u\n", cnt_to_uint(&sum));
-}
+}  /* simple_dump_const_tbl */
+
+/**
+ * Dumps a line of the parameter table
+ */
+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));
+}  /* dump_tbl_line */
+
+/**
+ * dumps the parameter distribution table
+ */
+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");
+
+	stat_iterate_distrib_tbl(tbl, dump_tbl_line, dmp);
+	fprintf(dmp->f, "-------------------------------\n");
+
+	fprintf(dmp->f, "Number of Calls           %12u\n", cnt_to_uint(&global->cnt[gcnt_all_calls]));
+	fprintf(dmp->f, "with const params         %12u\n", cnt_to_uint(&global->cnt[gcnt_call_with_cnst_arg]));
+	fprintf(dmp->f, "with all const params     %12u\n", cnt_to_uint(&global->cnt[gcnt_call_with_all_cnst_arg]));
+	fprintf(dmp->f, "with local var adr params %12u\n", cnt_to_uint(&global->cnt[gcnt_call_with_local_adr]));
+}  /* simple_dump_param_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
@@ -483,11 +604,14 @@ static void simple_finish(dumper_t *dmp)
 const dumper_t simple_dumper = {
 	simple_dump_graph,
 	simple_dump_const_tbl,
+	simple_dump_param_tbl,
 	simple_init,
 	simple_finish,
 	NULL,
 	NULL,
 	NULL,
+	NULL,
+	FOURCC('S', 'M', 'P', 'L'),
 };
 
 /* ---------------------------------------------------------------------- */
@@ -512,21 +636,18 @@ static void csv_count_nodes(dumper_t *dmp, graph_entry_t *graph, counter_t cnt[]
 		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
@@ -545,13 +666,12 @@ static void csv_dump_graph(dumper_t *dmp, graph_entry_t *entry)
 		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);
 
@@ -563,8 +683,8 @@ static void csv_dump_graph(dumper_t *dmp, graph_entry_t *entry)
 			cnt_to_uint(&cnt[2]),
 			cnt_to_uint(&cnt[3])
 		);
-	}
-}
+	}  /* if */
+}  /* csv_dump_graph */
 
 /**
  * dumps the IRG
@@ -572,7 +692,14 @@ static void csv_dump_graph(dumper_t *dmp, graph_entry_t *entry)
 static void csv_dump_const_tbl(dumper_t *dmp, const constant_info_t *tbl)
 {
 	/* FIXME: NYI */
-}
+}  /* csv_dump_const_tbl */
+
+/**
+ * dumps the parameter distribution table
+ */
+static void csv_dump_param_tbl(dumper_t *dmp, const distrib_tbl_t *tbl, graph_entry_t *global) {
+	/* FIXME: NYI */
+}  /* csv_dump_param_tbl */
 
 /**
  * initialize the simple dumper
@@ -585,7 +712,7 @@ static void csv_init(dumper_t *dmp, const char *name)
 	dmp->f = fopen(fname, "a");
 	if (! dmp->f)
 		perror(fname);
-}
+}  /* csv_init */
 
 /**
  * finishes the simple dumper
@@ -595,7 +722,7 @@ static void csv_finish(dumper_t *dmp)
 	if (dmp->f)
 		fclose(dmp->f);
 	dmp->f = NULL;
-}
+}  /* csv_finish */
 
 /**
  * the simple human readable dumper
@@ -603,9 +730,12 @@ static void csv_finish(dumper_t *dmp)
 const dumper_t csv_dumper = {
 	csv_dump_graph,
 	csv_dump_const_tbl,
+	csv_dump_param_tbl,
 	csv_init,
 	csv_finish,
 	NULL,
 	NULL,
 	NULL,
+	NULL,
+	FOURCC('C', 'S', 'V', '\0')
 };