X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=ir%2Fir%2Firdump.c;h=d6827465d9944d528f60d7aa11efe59e22481b27;hb=676ec77d725331ce22b8c12065a54c13074fd41c;hp=97b934bccac7bce911140d5dfaaf263b8da4272d;hpb=2ece936daec565575739be72f568a241207a5083;p=libfirm

diff --git a/ir/ir/irdump.c b/ir/ir/irdump.c
index 97b934bcc..d6827465d 100644
--- a/ir/ir/irdump.c
+++ b/ir/ir/irdump.c
@@ -29,8 +29,6 @@
 #include <stdlib.h>
 #include <stdarg.h>
 
-#include "firm_common_t.h"
-
 #include "list.h"
 
 #include "irnode_t.h"
@@ -40,6 +38,7 @@
 #include "irop.h"
 
 #include "irdump_t.h"
+#include "irpass_t.h"
 
 #include "irgwalk.h"
 #include "tv_t.h"
@@ -88,7 +87,9 @@ static int dump_backedge_information_flag = 1;
 /** An option to dump const-like nodes locally. */
 static int dump_const_local = 1;
 /** An option to dump the node index number. */
-static int dump_node_idx_labels = 0;
+static int dump_node_idx_labels = 1;
+/** An option to dump the node number */
+static int dump_node_nr = 1;
 /** An option to dump all graph anchors */
 static int dump_anchors = 0;
 /** An option to dump the macro block edges. */
@@ -114,108 +115,130 @@ static DUMP_NODE_EDGE_FUNC dump_block_edge_hook = NULL;
 static DUMP_NODE_EDGE_FUNC dump_node_edge_hook = NULL;
 
 /* Set the hook to be called to dump additional edges to a node. */
-void set_dump_node_edge_hook(DUMP_NODE_EDGE_FUNC func) {
+void set_dump_node_edge_hook(DUMP_NODE_EDGE_FUNC func)
+{
 	dump_node_edge_hook = func;
 }
 
 /* Get the additional edge dump hook. */
-DUMP_NODE_EDGE_FUNC get_dump_node_edge_hook(void) {
+DUMP_NODE_EDGE_FUNC get_dump_node_edge_hook(void)
+{
 	return dump_node_edge_hook;
 }
 
 /* Set the hook to be called to dump additional edges to a block. */
-void set_dump_block_edge_hook(DUMP_NODE_EDGE_FUNC func) {
+void set_dump_block_edge_hook(DUMP_NODE_EDGE_FUNC func)
+{
 	dump_block_edge_hook = func;
 }
 
 /* Get the additional block edge dump hook. */
-DUMP_NODE_EDGE_FUNC get_dump_block_edge_hook(void) {
+DUMP_NODE_EDGE_FUNC get_dump_block_edge_hook(void)
+{
 	return dump_node_edge_hook;
 }
 
 /* set the ir graph hook */
-void set_dump_ir_graph_hook(DUMP_IR_GRAPH_FUNC hook) {
+void set_dump_ir_graph_hook(DUMP_IR_GRAPH_FUNC hook)
+{
 	dump_ir_graph_hook = hook;
 }
 
 /* set the node attribute hook */
-void set_dump_node_vcgattr_hook(DUMP_NODE_VCGATTR_FUNC hook) {
+void set_dump_node_vcgattr_hook(DUMP_NODE_VCGATTR_FUNC hook)
+{
 	dump_node_vcgattr_hook = hook;
 }
 
 /* set the edge attribute hook */
-void set_dump_edge_vcgattr_hook(DUMP_EDGE_VCGATTR_FUNC hook) {
+void set_dump_edge_vcgattr_hook(DUMP_EDGE_VCGATTR_FUNC hook)
+{
 	dump_edge_vcgattr_hook = hook;
 }
 
 /** Returns 0 if dump_out_edge_flag or dump_loop_information_flag
  * are set, else returns dump_const_local_flag.
  */
-static int get_opt_dump_const_local(void) {
+static int get_opt_dump_const_local(void)
+{
 	if (dump_out_edge_flag || dump_loop_information_flag || (dump_new_edges_flag && edges_activated(current_ir_graph)))
 		return 0;
 	return dump_const_local;
 }
 
 /* Set a prefix filter for output functions. */
-void only_dump_method_with_name(ident *name) {
+void only_dump_method_with_name(ident *name)
+{
 	dump_file_filter_id = name;
 }
 
 /* Returns the prefix filter set with only_dump_method_with_name(). */
-ident *get_dump_file_filter_ident(void) {
+ident *get_dump_file_filter_ident(void)
+{
 	return dump_file_filter_id;
 }
 
 /* Returns non-zero if dump file filter is not set, or if it is a prefix of name. */
-int is_filtered_dump_name(ident *name) {
+int is_filtered_dump_name(ident *name)
+{
 	if (!dump_file_filter_id) return 1;
 	return id_is_prefix(dump_file_filter_id, name);
 }
 
 /* To turn off display of edge labels.  Edge labels often cause xvcg to
    abort with a segmentation fault. */
-void turn_off_edge_labels(void) {
+void turn_off_edge_labels(void)
+{
 	edge_label = 0;
 }
 
-void dump_consts_local(int flag) {
+void dump_consts_local(int flag)
+{
 	dump_const_local = flag;
 }
 
-void dump_node_idx_label(int flag) {
+void dump_node_idx_label(int flag)
+{
 	dump_node_idx_labels = flag;
 }
 
-void dump_constant_entity_values(int flag) {
+void dump_constant_entity_values(int flag)
+{
 	const_entities = flag;
 }
 
-void dump_keepalive_edges(int flag) {
+void dump_keepalive_edges(int flag)
+{
 	dump_keepalive = flag;
 }
 
-void dump_new_edges(int flag) {
+void dump_new_edges(int flag)
+{
 	dump_new_edges_flag = flag;
 }
 
-int get_opt_dump_keepalive_edges(void) {
+int get_opt_dump_keepalive_edges(void)
+{
 	return dump_keepalive;
 }
 
-void dump_out_edges(int flag) {
+void dump_out_edges(int flag)
+{
 	dump_out_edge_flag = flag;
 }
 
-void dump_dominator_information(int flag) {
+void dump_dominator_information(int flag)
+{
 	dump_dominator_information_flag = flag;
 }
 
-void dump_loop_information(int flag) {
+void dump_loop_information(int flag)
+{
 	dump_loop_information_flag = flag;
 }
 
-void dump_backedge_information(int flag) {
+void dump_backedge_information(int flag)
+{
 	dump_backedge_information_flag = flag;
 }
 
@@ -223,27 +246,33 @@ void dump_backedge_information(int flag) {
  * If the flag is set, the type name is output in [] in the node label,
  * else it is output as info.
  */
-void set_opt_dump_analysed_type_info(int flag) {
+void set_opt_dump_analysed_type_info(int flag)
+{
 	opt_dump_analysed_type_info = flag;
 }
 
-void dump_pointer_values_to_info(int flag) {
+void dump_pointer_values_to_info(int flag)
+{
 	opt_dump_pointer_values_to_info = flag;
 }
 
-void dump_ld_names(int flag) {
+void dump_ld_names(int flag)
+{
 	dump_ld_name = flag;
 }
 
-void dump_all_anchors(int flag) {
+void dump_all_anchors(int flag)
+{
 	dump_anchors = flag;
 }
 
-void dump_macroblock_edges(int flag) {
+void dump_macroblock_edges(int flag)
+{
 	dump_macro_block_edges = flag;
 }
 
-void dump_block_marker_in_title(int flag) {
+void dump_block_marker_in_title(int flag)
+{
 	dump_block_marker = flag;
 }
 
@@ -253,24 +282,14 @@ void dump_block_marker_in_title(int flag) {
  * returns the name of a mode or ERROR_TXT if mode is NOT a mode object.
  * in the later case, sets bad.
  */
-const char *get_mode_name_ex(const ir_mode *mode, int *bad) {
+const char *get_mode_name_ex(const ir_mode *mode, int *bad)
+{
 	if (is_mode(mode))
 		return get_mode_name(mode);
 	*bad |= 1;
 	return ERROR_TXT;
 }
 
-/**
- * returns the name of a type or <ERROR> if mode is NOT a mode object.
- * in the later case, sets bad
- */
-const char *get_type_name_ex(const ir_type *tp, int *bad) {
-	if (is_type(tp))
-		return get_type_name(tp);
-	*bad |= 1;
-	return ERROR_TXT;
-}
-
 #define CUSTOM_COLOR_BASE    100
 static const char *color_names[ird_color_count];
 static const char *color_rgb[ird_color_count];
@@ -325,11 +344,26 @@ static void init_colors(void)
 /**
  * Prints the VCG color to a file.
  */
-static void print_vcg_color(FILE *F, ird_color_t color) {
+static void print_vcg_color(FILE *F, ird_color_t color)
+{
 	assert(color < ird_color_count);
 	fprintf(F, "color:%s", color_names[color]);
 }
 
+/**
+ * Prints the edge kind of a given IR node.
+ *
+ * Projs should be dumped near their predecessor, so they get "nearedge".
+ */
+static void print_node_edge_kind(FILE *F, ir_node *node)
+{
+	if (is_Proj(node)) {
+		fprintf(F, "nearedge: ");
+	} else {
+		fprintf(F, "edge: ");
+	}
+}
+
 /**
  * Prints the edge from a type S to a type T with additional info fmt, ...
  * to the file F.
@@ -490,7 +524,8 @@ static pmap *irdump_link_map = NULL;
  * initialization is performed lazily and not called from within init_firm.
  *
  * Creates the link attribute map. */
-static void init_irdump(void) {
+static void init_irdump(void)
+{
 	/* We need a new, empty map. */
 	if (irdump_link_map) pmap_destroy(irdump_link_map);
 	irdump_link_map = pmap_create();
@@ -501,7 +536,8 @@ static void init_irdump(void) {
 /**
  * Returns the private link field.
  */
-static void *ird_get_irn_link(const ir_node *n) {
+static void *ird_get_irn_link(const ir_node *n)
+{
 	void *res = NULL;
 	if (irdump_link_map == NULL)
 		return NULL;
@@ -514,7 +550,8 @@ static void *ird_get_irn_link(const ir_node *n) {
 /**
  * Sets the private link field.
  */
-static void ird_set_irn_link(const ir_node *n, void *x) {
+static void ird_set_irn_link(const ir_node *n, void *x)
+{
 	if (irdump_link_map == NULL)
 		init_irdump();
 	pmap_insert(irdump_link_map, n, x);
@@ -523,7 +560,8 @@ static void ird_set_irn_link(const ir_node *n, void *x) {
 /**
  * Gets the private link field of an irg.
  */
-static void *ird_get_irg_link(const ir_graph *irg) {
+static void *ird_get_irg_link(const ir_graph *irg)
+{
 	void *res = NULL;
 	if (irdump_link_map == NULL)
 		return NULL;
@@ -536,7 +574,8 @@ static void *ird_get_irg_link(const ir_graph *irg) {
 /**
  * Sets the private link field of an irg.
  */
-static void ird_set_irg_link(const ir_graph *irg, void *x) {
+static void ird_set_irg_link(const ir_graph *irg, void *x)
+{
 	if (irdump_link_map == NULL)
 		init_irdump();
 	pmap_insert(irdump_link_map, irg, x);
@@ -545,7 +584,8 @@ static void ird_set_irg_link(const ir_graph *irg, void *x) {
 /**
  * Walker, clears the private link field.
  */
-static void clear_link(ir_node *node, void *env) {
+static void clear_link(ir_node *node, void *env)
+{
 	(void) env;
 	ird_set_irn_link(node, NULL);
 }
@@ -554,7 +594,8 @@ static void clear_link(ir_node *node, void *env) {
  * If the entity has a ld_name, returns it if the dump_ld_name is set,
  * else returns the name of the entity.
  */
-static const char *_get_ent_dump_name(const ir_entity *ent, int dump_ld_name) {
+static const char *_get_ent_dump_name(const ir_entity *ent, int dump_ld_name)
+{
 	if (ent == NULL)
 		return "<NULL entity>";
 	if (dump_ld_name) {
@@ -569,12 +610,14 @@ static const char *_get_ent_dump_name(const ir_entity *ent, int dump_ld_name) {
  * If the entity has a ld_name, returns it if the option dump_ld_name is set,
  * else returns the name of the entity.
  */
-const char *get_ent_dump_name(const ir_entity *ent) {
+const char *get_ent_dump_name(const ir_entity *ent)
+{
 	return _get_ent_dump_name(ent, dump_ld_name);
 }
 
 /* Returns the name of an IRG. */
-const char *get_irg_dump_name(const ir_graph *irg) {
+const char *get_irg_dump_name(const ir_graph *irg)
+{
 	/* Don't use get_entity_ld_ident (ent) as it computes the mangled name! */
 	return _get_ent_dump_name(get_irg_entity(irg), 1);
 }
@@ -582,7 +625,8 @@ const char *get_irg_dump_name(const ir_graph *irg) {
 /**
  * Returns non-zero if a node is in floating state.
  */
-static int node_floats(const ir_node *n) {
+static int node_floats(const ir_node *n)
+{
 	return ((get_irn_pinned(n) == op_pin_state_floats) &&
 	        (get_irg_pinned(current_ir_graph) == op_pin_state_floats));
 }
@@ -590,7 +634,8 @@ static int node_floats(const ir_node *n) {
 /**
  *  Walker that visits the anchors
  */
-static void ird_walk_graph(ir_graph *irg, irg_walk_func *pre, irg_walk_func *post, void *env) {
+static void ird_walk_graph(ir_graph *irg, irg_walk_func *pre, irg_walk_func *post, void *env)
+{
 	if (dump_anchors || (dump_new_edges_flag && edges_activated(irg))) {
 		irg_walk_anchors(irg, pre, post, env);
 	} else {
@@ -601,7 +646,8 @@ static void ird_walk_graph(ir_graph *irg, irg_walk_func *pre, irg_walk_func *pos
 /**
  * Walker, allocates an array for all blocks and puts it's nodes non-floating nodes into this array.
  */
-static void collect_node(ir_node *node, void *env) {
+static void collect_node(ir_node *node, void *env)
+{
 	(void) env;
 	if (is_Block(node)
 	    || node_floats(node)
@@ -634,7 +680,8 @@ static void collect_node(ir_node *node, void *env) {
  * graphs not visited.
  * Free the list with DEL_ARR_F().
  */
-static ir_node **construct_block_lists(ir_graph *irg) {
+static ir_node **construct_block_lists(ir_graph *irg)
+{
 	int      i;
 #ifdef INTERPROCEDURAL_VIEW
 	int      rem_view  = get_interprocedural_view();
@@ -644,7 +691,7 @@ static ir_node **construct_block_lists(ir_graph *irg) {
 
 	current_ir_graph = irg;
 
-	if(walk_flag) {
+	if (walk_flag) {
 		ir_free_resources(irg, IR_RESOURCE_IRN_VISITED);
 	}
 
@@ -685,7 +732,8 @@ typedef struct _list_tuple {
  * Sets the irg link field to NULL in all
  * graphs not visited.
  */
-static list_tuple *construct_extblock_lists(ir_graph *irg) {
+static list_tuple *construct_extblock_lists(ir_graph *irg)
+{
 	ir_node **blk_list = construct_block_lists(irg);
 	int i;
 	ir_graph *rem = current_ir_graph;
@@ -737,10 +785,6 @@ int dump_node_opcode(FILE *F, ir_node *n)
 	switch (get_irn_opcode(n)) {
 	case iro_SymConst:
 		switch (get_SymConst_kind(n)) {
-		case symconst_addr_name:
-			/* don't use get_SymConst_ptr_info as it mangles the name. */
-			fprintf(F, "SymC %s", get_id_str(get_SymConst_name(n)));
-			break;
 		case symconst_addr_ent:
 			fprintf(F, "SymC &%s", get_entity_name(get_SymConst_entity(n)));
 			break;
@@ -748,29 +792,28 @@ int dump_node_opcode(FILE *F, ir_node *n)
 			fprintf(F, "SymC %s offset", get_entity_name(get_SymConst_entity(n)));
 			break;
 		case symconst_type_tag:
-			fprintf(F, "SymC %s tag", get_type_name_ex(get_SymConst_type(n), &bad));
+			ir_fprintf(F, "SymC %+F tag", get_SymConst_type(n));
 			break;
 		case symconst_type_size:
-			fprintf(F, "SymC %s size", get_type_name_ex(get_SymConst_type(n), &bad));
+			ir_fprintf(F, "SymC %+F size", get_SymConst_type(n));
 			break;
 		case symconst_type_align:
-			fprintf(F, "SymC %s align", get_type_name_ex(get_SymConst_type(n), &bad));
+			ir_fprintf(F, "SymC %+F align", get_SymConst_type(n));
 			break;
 		case symconst_enum_const:
-			fprintf(F, "SymC %s enum", get_enumeration_name(get_SymConst_enum(n)));
-			break;
-		case symconst_label:
-			fprintf(F, "SymC %lu label", get_SymConst_label(n));
+			fprintf(F, "SymC %s enum", get_enumeration_const_name(get_SymConst_enum(n)));
 			break;
 		}
 		break;
 
+#ifdef INTERPROCEDURAL_VIEW
 	case iro_Filter:
 		if (!get_interprocedural_view())
 			fprintf(F, "Proj'");
 		else
 			goto default_case;
 		break;
+#endif
 
 	case iro_Proj: {
 		ir_node *pred = get_Proj_pred(n);
@@ -782,6 +825,8 @@ int dump_node_opcode(FILE *F, ir_node *n)
 		else
 			goto default_case;
 	} break;
+
+#ifdef INTERPROCEDURAL_VIEW
 	case iro_Start:
 	case iro_End:
 	case iro_EndExcept:
@@ -791,6 +836,7 @@ int dump_node_opcode(FILE *F, ir_node *n)
 			break;
 		} else
 			goto default_case;
+#endif
 
 	case iro_CallBegin: {
 		ir_node *addr = get_CallBegin_ptr(n);
@@ -814,8 +860,13 @@ int dump_node_opcode(FILE *F, ir_node *n)
 		fprintf(F, "%s", get_irn_opname(n));
 		break;
 	case iro_Block:
-		fprintf(F, "%s%s%s",
-			is_Block_dead(n) ? "Dead " : "", get_irn_opname(n),
+		if (is_Block_dead(n))
+			fputs("Dead ", F);
+		if (n == get_irg_start_block(get_irn_irg(n)))
+			fputs("Start ", F);
+		if (n == get_irg_end_block(get_irn_irg(n)))
+			fputs("End ", F);
+		fprintf(F, "%s%s", get_irn_opname(n),
 			dump_block_marker ? (get_Block_mark(n) ? "*" : "") : "");
 		break;
 	case iro_Conv:
@@ -887,17 +938,19 @@ static int dump_node_mode(FILE *F, ir_node *n)
 /**
  * Dump the type of a node n to a file F if it's known.
  */
-static int dump_node_typeinfo(FILE *F, ir_node *n) {
+static int dump_node_typeinfo(FILE *F, ir_node *n)
+{
 	int bad = 0;
 
 	if (opt_dump_analysed_type_info) {
 		if (get_irg_typeinfo_state(current_ir_graph) == ir_typeinfo_consistent  ||
 			get_irg_typeinfo_state(current_ir_graph) == ir_typeinfo_inconsistent) {
 			ir_type *tp = get_irn_typeinfo_type(n);
-			if (tp != firm_none_type)
-				fprintf(F, "[%s] ", get_type_name_ex(tp, &bad));
-			else
+			if (tp != firm_none_type) {
+				ir_fprintf(F, "[%+F]", tp);
+			} else {
 				fprintf(F, "[] ");
+			}
 		}
 	}
 	return bad;
@@ -937,11 +990,10 @@ static const pns_lookup_t cond_lut[] = {
 /** the lookup table for Proj(Call) names */
 static const pns_lookup_t call_lut[] = {
 #define X(a)    { pn_Call_##a, #a }
-	X(M_regular),
+	X(M),
 	X(X_regular),
 	X(X_except),
 	X(T_result),
-	X(M_except),
 	X(P_value_res_base)
 #undef X
 };
@@ -1022,7 +1074,6 @@ static const pns_lookup_t copyb_lut[] = {
 	X(M),
 	X(X_regular),
 	X(X_except),
-	X(M_except)
 #undef X
 };
 
@@ -1033,7 +1084,6 @@ static const pns_lookup_t instof_lut[] = {
 	X(X_regular),
 	X(X_except),
 	X(res),
-	X(M_except),
 #undef X
 };
 
@@ -1078,8 +1128,7 @@ static const proj_lookup_t proj_lut[] = {
 /**
  * Dump additional node attributes of some nodes to a file F.
  */
-static int
-dump_node_nodeattr(FILE *F, ir_node *n)
+static int dump_node_nodeattr(FILE *F, ir_node *n)
 {
 	int bad = 0;
 	ir_node *pred;
@@ -1092,12 +1141,6 @@ dump_node_nodeattr(FILE *F, ir_node *n)
 		return ops->dump_node(n, F, dump_node_nodeattr_txt);
 
 	switch (get_irn_opcode(n)) {
-	case iro_Start:
-		if (0 && get_interprocedural_view()) {
-			fprintf(F, "%s ", get_ent_dump_name(get_irg_entity(current_ir_graph)));
-		}
-		break;
-
 	case iro_Const:
 		ir_fprintf(F, "%T ", get_Const_tarval(n));
 		break;
@@ -1105,7 +1148,9 @@ dump_node_nodeattr(FILE *F, ir_node *n)
 	case iro_Proj:
 		pred    = get_Proj_pred(n);
 		proj_nr = get_Proj_proj(n);
+#ifdef INTERPROCEDURAL_VIEW
 handle_lut:
+#endif
 		code    = get_irn_opcode(pred);
 
 		if (code == iro_Cmp)
@@ -1141,24 +1186,26 @@ handle_lut:
 		break;
 	case iro_Filter:
 		proj_nr = get_Filter_proj(n);
+#ifdef INTERPROCEDURAL_VIEW
 		if (! get_interprocedural_view()) {
 			/* it's a Proj' */
 			pred    = get_Filter_pred(n);
 			goto handle_lut;
 		} else
+#endif
 			fprintf(F, "%ld ", proj_nr);
 		break;
 	case iro_Sel:
 		fprintf(F, "%s ", get_ent_dump_name(get_Sel_entity(n)));
 		break;
 	case iro_Cast:
-		fprintf(F, "(%s) ", get_type_name_ex(get_Cast_type(n), &bad));
+		ir_fprintf(F, "(%+F)", get_Cast_type(n));
 		break;
 	case iro_Confirm:
 		fprintf(F, "%s ", get_pnc_string(get_Confirm_cmp(n)));
 		break;
 	case iro_CopyB:
-		fprintf(F, "(%s) ", get_type_name_ex(get_CopyB_type(n), &bad));
+		ir_fprintf(F, "(%+F)", get_CopyB_type(n));
 		break;
 
 	default:
@@ -1171,7 +1218,8 @@ handle_lut:
 #include <math.h>
 #include "execution_frequency.h"
 
-static void dump_node_ana_vals(FILE *F, ir_node *n) {
+static void dump_node_ana_vals(FILE *F, ir_node *n)
+{
 	(void) F;
 	(void) n;
 	return;
@@ -1187,23 +1235,46 @@ static void dump_node_ana_vals(FILE *F, ir_node *n) {
 
 
 /* Dumps a node label without the enclosing ". */
-int dump_node_label(FILE *F, ir_node *n) {
+int dump_node_label(FILE *F, ir_node *n)
+{
 	int bad = 0;
 
 	bad |= dump_node_opcode(F, n);
+	fputs(" ", F);
 	bad |= dump_node_mode(F, n);
 	fprintf(F, " ");
 	bad |= dump_node_typeinfo(F, n);
 	bad |= dump_node_nodeattr(F, n);
-	if(dump_node_idx_labels) {
-		fprintf(F, "%ld:%d", get_irn_node_nr(n), get_irn_idx(n));
-	} else {
+	if (dump_node_nr) {
 		fprintf(F, "%ld", get_irn_node_nr(n));
 	}
+	if (dump_node_idx_labels) {
+		fprintf(F, ":%u", get_irn_idx(n));
+	}
 
 	return bad;
 }
 
+/* Dumps the vrp information of a node to a file */
+int dump_vrp_info(FILE *F, ir_node *n)
+{
+	vrp_attr *vrp = vrp_get_info(n);
+	if (!n) {
+		return 1;
+	}
+
+	fprintf(F, "range_type: %d\n", (int) vrp->range_type);
+	if (vrp->range_type == VRP_RANGE || vrp->range_type ==
+			VRP_ANTIRANGE) {
+		ir_fprintf(F, "range_bottom: %F\n",vrp->range_bottom);
+		ir_fprintf(F, "range_top: %F\n", vrp->range_top);
+	}
+	ir_fprintf(F, "bits_set: %T\n", vrp->bits_set);
+	ir_fprintf(F, "bits_not_set: %T\n", vrp->bits_not_set);
+
+	return 0;
+}
+
 /**
  * Dumps the attributes of a node n into the file F.
  * Currently this is only the color of a node.
@@ -1230,11 +1301,11 @@ static void dump_node_vcgattr(FILE *F, ir_node *node, ir_node *local, int bad)
 	}
 
 	mode = get_irn_mode(n);
-	if(mode == mode_M) {
+	if (mode == mode_M) {
 		print_vcg_color(F, ird_color_memory);
 		return;
 	}
-	if(mode == mode_X) {
+	if (mode == mode_X) {
 		print_vcg_color(F, ird_color_controlflow);
 		return;
 	}
@@ -1271,14 +1342,12 @@ static void dump_node_vcgattr(FILE *F, ir_node *node, ir_node *local, int bad)
 	default: {
 		ir_op *op = get_irn_op(node);
 
-		if(is_op_constlike(op)) {
+		if (is_op_constlike(op)) {
 			print_vcg_color(F, ird_color_const);
-		} else if(is_op_uses_memory(op)) {
+		} else if (is_op_uses_memory(op)) {
 			print_vcg_color(F, ird_color_uses_memory);
-		} else if(is_op_cfopcode(op) || is_op_forking(op)) {
+		} else if (is_op_cfopcode(op) || is_op_forking(op)) {
 			print_vcg_color(F, ird_color_controlflow);
-		} else {
-			PRINT_DEFAULT_NODE_ATTR;
 		}
 	}
 	}
@@ -1334,7 +1403,8 @@ static inline int is_constlike_node(const ir_node *node)
 
 /** outputs the predecessors of n, that are constants, local.  I.e.,
    generates a copy of the constant predecessors for each node called with. */
-static void dump_const_node_local(FILE *F, ir_node *n) {
+static void dump_const_node_local(FILE *F, ir_node *n)
+{
 	int i;
 	if (!get_opt_dump_const_local()) return;
 
@@ -1367,7 +1437,8 @@ static void dump_const_node_local(FILE *F, ir_node *n) {
 }
 
 /** If the block of an edge is a const_like node, dump it local with an edge */
-static void dump_const_block_local(FILE *F, ir_node *n) {
+static void dump_const_block_local(FILE *F, ir_node *n)
+{
 	ir_node *blk;
 
 	if (!get_opt_dump_const_local()) return;
@@ -1423,13 +1494,19 @@ static void print_dbg_info(FILE *F, dbg_info *dbg)
 {
 	char buf[1024];
 
-	if (__dbg_info_snprint) {
-		buf[0] = '\0';
-		if (__dbg_info_snprint(buf, sizeof(buf), dbg) > 0)
-			fprintf(F, " info3: \"%s\"\n", buf);
+	ir_dbg_info_snprint(buf, sizeof(buf), dbg);
+	if (buf[0] != 0) {
+		fprintf(F, " info3: \"%s\"\n", buf);
 	}
 }
 
+static void print_type_dbg_info(FILE *F, type_dbg_info *dbg)
+{
+	(void) F;
+	(void) dbg;
+	/* TODO */
+}
+
 /**
  * Dump a node
  */
@@ -1464,13 +1541,13 @@ static void dump_node(FILE *F, ir_node *n)
 	fputs("}\n", F);
 	dump_const_node_local(F, n);
 
-	if(dump_node_edge_hook)
+	if (dump_node_edge_hook)
 		dump_node_edge_hook(F, n);
 }
 
 /** dump the edge to the block this node belongs to */
-static void
-dump_ir_block_edge(FILE *F, ir_node *n)  {
+static void dump_ir_block_edge(FILE *F, ir_node *n)
+{
 	if (get_opt_dump_const_local() && is_constlike_node(n)) return;
 	if (is_no_Block(n)) {
 		ir_node *block = get_nodes_block(n);
@@ -1499,8 +1576,8 @@ dump_ir_block_edge(FILE *F, ir_node *n)  {
 	}
 }
 
-static void
-print_data_edge_vcgattr(FILE *F, ir_node *from, int to) {
+static void print_data_edge_vcgattr(FILE *F, ir_node *from, int to)
+{
 	/*
 	 * do not use get_nodes_block() here, will fail
 	 * if the irg is not pinned.
@@ -1511,8 +1588,8 @@ print_data_edge_vcgattr(FILE *F, ir_node *from, int to) {
 		fprintf(F, INTER_DATA_EDGE_ATTR);
 }
 
-static void
-print_mem_edge_vcgattr(FILE *F, ir_node *from, int to) {
+static void print_mem_edge_vcgattr(FILE *F, ir_node *from, int to)
+{
 	/*
 	 * do not use get_nodes_block() here, will fail
 	 * if the irg is not pinned.
@@ -1524,7 +1601,8 @@ print_mem_edge_vcgattr(FILE *F, ir_node *from, int to) {
 }
 
 /** Print the vcg attributes for the edge from node from to it's to's input */
-static void print_edge_vcgattr(FILE *F, ir_node *from, int to) {
+static void print_edge_vcgattr(FILE *F, ir_node *from, int to)
+{
 	assert(from);
 
 	if (dump_edge_vcgattr_hook)
@@ -1566,9 +1644,9 @@ static void print_edge_vcgattr(FILE *F, ir_node *from, int to) {
 }
 
 /** dump edges to our inputs */
-static void dump_ir_data_edges(FILE *F, ir_node *n)  {
+static void dump_ir_data_edges(FILE *F, ir_node *n)
+{
 	int i, num;
-	ir_visited_t visited = get_irn_visited(n);
 
 	if (!dump_keepalive && is_End(n)) {
 		/* the End node has only keep-alive edges */
@@ -1581,7 +1659,8 @@ static void dump_ir_data_edges(FILE *F, ir_node *n)  {
 		ir_node *dep = get_irn_dep(n, i);
 
 		if (dep) {
-			fprintf(F, "edge: {sourcename: \"");
+			print_node_edge_kind(F, n);
+			fprintf(F, "{sourcename: \"");
 			PRINT_NODEID(n);
 			fprintf(F, "\" targetname: ");
 			if ((get_opt_dump_const_local()) && is_constlike_node(dep)) {
@@ -1601,13 +1680,17 @@ static void dump_ir_data_edges(FILE *F, ir_node *n)  {
 		ir_node *pred = get_irn_n(n, i);
 		assert(pred);
 
-		if ((get_interprocedural_view() && get_irn_visited(pred) < visited))
+#ifdef INTERPROCEDURAL_VIEW
+		if ((get_interprocedural_view() && get_irn_visited(pred) < get_irn_visited(n)))
 			continue; /* pred not dumped */
+#endif
 
 		if (dump_backedge_information_flag && is_backedge(n, i))
 			fprintf(F, "backedge: {sourcename: \"");
-		else
-			fprintf(F, "edge: {sourcename: \"");
+		else {
+			print_node_edge_kind(F, n);
+			fprintf(F, "{sourcename: \"");
+		}
 		PRINT_NODEID(n);
 		fprintf(F, "\" targetname: ");
 		if ((get_opt_dump_const_local()) && is_constlike_node(pred)) {
@@ -1634,15 +1717,16 @@ static void dump_ir_data_edges(FILE *F, ir_node *n)  {
 /**
  * Dump the ir_edges
  */
-static void
-dump_ir_edges(FILE *F, ir_node *n) {
+static void dump_ir_edges(FILE *F, ir_node *n)
+{
 	const ir_edge_t *edge;
 	int i = 0;
 
 	foreach_out_edge(n, edge) {
 		ir_node *succ = get_edge_src_irn(edge);
 
-		fprintf(F, "edge: {sourcename: \"");
+		print_node_edge_kind(F, succ);
+		fprintf(F, "{sourcename: \"");
 		PRINT_NODEID(n);
 		fprintf(F, "\" targetname: \"");
 		PRINT_NODEID(succ);
@@ -1657,14 +1741,16 @@ dump_ir_edges(FILE *F, ir_node *n) {
 
 
 /** Dumps a node and its edges but not the block edge  */
-static void dump_node_wo_blockedge(ir_node *n, void *env) {
+static void dump_node_wo_blockedge(ir_node *n, void *env)
+{
 	FILE *F = env;
 	dump_node(F, n);
 	dump_ir_data_edges(F, n);
 }
 
 /** Dumps a node and its edges. */
-static void dump_whole_node(ir_node *n, void *env) {
+static void dump_whole_node(ir_node *n, void *env)
+{
 	FILE *F = env;
 	dump_node_wo_blockedge(n, env);
 	if (!node_floats(n))
@@ -1674,7 +1760,8 @@ static void dump_whole_node(ir_node *n, void *env) {
 }
 
 /** Dumps a const-like node. */
-static void dump_const_node(ir_node *n, void *env) {
+static void dump_const_node(ir_node *n, void *env)
+{
 	if (is_Block(n)) return;
 	dump_node_wo_blockedge(n, env);
 }
@@ -1685,7 +1772,8 @@ static void dump_const_node(ir_node *n, void *env) {
 
 /** Dumps a constant expression as entity initializer, array bound ...
  */
-static void dump_const_expression(FILE *F, ir_node *value) {
+static void dump_const_expression(FILE *F, ir_node *value)
+{
 	ir_graph *rem = current_ir_graph;
 	int rem_dump_const_local = dump_const_local;
 	dump_const_local = 0;
@@ -1704,7 +1792,8 @@ static void dump_const_expression(FILE *F, ir_node *value) {
  *  Expects to find nodes belonging to the block as list in its
  *  link field.
  *  Dumps the edges of all nodes including itself. */
-static void dump_whole_block(FILE *F, ir_node *block) {
+static void dump_whole_block(FILE *F, ir_node *block)
+{
 	ir_node *node;
 	ird_color_t color = ird_color_block_background;
 
@@ -1749,8 +1838,8 @@ static void dump_whole_block(FILE *F, ir_node *block) {
 
 /** dumps a graph block-wise. Expects all blockless nodes in arr in irgs link.
  *  The outermost nodes: blocks and nodes not op_pin_state_pinned, Bad, Unknown. */
-static void
-dump_block_graph(FILE *F, ir_graph *irg) {
+static void dump_block_graph(FILE *F, ir_graph *irg)
+{
 	int i;
 	ir_graph *rem = current_ir_graph;
 	ir_node **arr = ird_get_irg_link(irg);
@@ -1784,7 +1873,8 @@ dump_block_graph(FILE *F, ir_graph *irg) {
  * Dump the info for an irg.
  * Parsed by XVCG but not shown. use yComp.
  */
-static void dump_graph_info(FILE *F, ir_graph *irg) {
+static void dump_graph_info(FILE *F, ir_graph *irg)
+{
 	fprintf(F, "info1: \"");
 	dump_entity_to_file(F, get_irg_entity(irg), dump_verbosity_entattrs | dump_verbosity_entconsts);
 	fprintf(F, "\"\n");
@@ -1793,7 +1883,8 @@ static void dump_graph_info(FILE *F, ir_graph *irg) {
 /** Dumps an irg as a graph clustered by block nodes.
  *  If interprocedural view edges can point to nodes out of this graph.
  */
-static void dump_graph_from_list(FILE *F, ir_graph *irg) {
+static void dump_graph_from_list(FILE *F, ir_graph *irg)
+{
 	ir_entity *ent = get_irg_entity(irg);
 
 	fprintf(F, "graph: { title: \"");
@@ -1812,8 +1903,8 @@ static void dump_graph_from_list(FILE *F, ir_graph *irg) {
 
 /** dumps a graph extended block-wise. Expects all blockless nodes in arr in irgs link.
  *  The outermost nodes: blocks and nodes not op_pin_state_pinned, Bad, Unknown. */
-static void
-dump_extblock_graph(FILE *F, ir_graph *irg) {
+static void dump_extblock_graph(FILE *F, ir_graph *irg)
+{
 	int i;
 	ir_graph *rem = current_ir_graph;
 	ir_extblk **arr = ird_get_irg_link(irg);
@@ -1894,7 +1985,8 @@ static void dump_node2type_edges(ir_node *n, void *env)
 }
 
 #if 0
-static int print_type_info(FILE *F, ir_type *tp) {
+static int print_type_info(FILE *F, ir_type *tp)
+{
 	int bad = 0;
 
 	if (get_type_state(tp) == layout_undefined) {
@@ -1909,7 +2001,8 @@ static int print_type_info(FILE *F, ir_type *tp) {
 	return bad;
 }
 
-static void print_typespecific_info(FILE *F, ir_type *tp) {
+static void print_typespecific_info(FILE *F, ir_type *tp)
+{
 	switch (get_type_tpop_code(tp)) {
 	case tpo_class:
 		fprintf(F, "peculiarity: %s\n", get_peculiarity_string(get_class_peculiarity(tp)));
@@ -1937,13 +2030,11 @@ static void print_typespecific_info(FILE *F, ir_type *tp) {
 }
 #endif
 
-static void print_typespecific_vcgattr(FILE *F, ir_type *tp) {
+static void print_typespecific_vcgattr(FILE *F, ir_type *tp)
+{
 	switch (get_type_tpop_code(tp)) {
 	case tpo_class:
-		if (peculiarity_existent == get_class_peculiarity(tp))
-			fprintf(F, " " TYPE_CLASS_NODE_ATTR);
-		else
-			fprintf(F, " " TYPE_DESCRIPTION_NODE_ATTR);
+		fprintf(F, " " TYPE_CLASS_NODE_ATTR);
 		break;
 	case tpo_struct:
 		fprintf(F, " " TYPE_METH_NODE_ATTR);
@@ -1965,23 +2056,16 @@ static void print_typespecific_vcgattr(FILE *F, ir_type *tp) {
 	} /* switch type */
 }
 
-
 int dump_type_node(FILE *F, ir_type *tp)
 {
 	int bad = 0;
 
 	fprintf(F, "node: {title: ");
 	PRINT_TYPEID(tp);
-	fprintf(F, " label: \"%s %s\"", get_type_tpop_name(tp), get_type_name_ex(tp, &bad));
-	fprintf(F, " info1: \"");
-#if 0
-	bad |= print_type_info(F, tp);
-	print_typespecific_info(F, tp);
-#else
+	ir_fprintf(F, " label: \"%s %+F\" info1: \"", get_type_tpop_name(tp), tp);
 	dump_type_to_file(F, tp, dump_verbosity_max);
-#endif
 	fprintf(F, "\"\n");
-	print_dbg_info(F, get_type_dbg_info(tp));
+	print_type_dbg_info(F, get_type_dbg_info(tp));
 	print_typespecific_vcgattr(F, tp);
 	fprintf(F, "}\n");
 
@@ -1989,12 +2073,11 @@ int dump_type_node(FILE *F, ir_type *tp)
 }
 
 
-void dump_entity_node(FILE *F, ir_entity *ent)
+static void dump_entity_node(FILE *F, ir_entity *ent)
 {
 	fprintf(F, "node: {title: \"");
 	PRINT_ENTID(ent); fprintf(F, "\"");
-	fprintf(F, DEFAULT_TYPE_ATTRIBUTE);
-	fprintf(F, "label: ");
+	fprintf(F, " label: ");
 	fprintf(F, "\"%s\" ", get_ent_dump_name(ent));
 
 	print_vcg_color(F, ird_color_entity);
@@ -2011,7 +2094,7 @@ static void dump_enum_item(FILE *F, ir_type *tp, int pos)
 {
 	char buf[1024];
 	ir_enum_const *ec = get_enumeration_const(tp, pos);
-	ident         *id = get_enumeration_nameid(ec);
+	ident         *id = get_enumeration_const_nameid(ec);
 	tarval        *tv = get_enumeration_value(ec);
 
 	if (tv)
@@ -2020,8 +2103,7 @@ static void dump_enum_item(FILE *F, ir_type *tp, int pos)
 		strncpy(buf, "<not set>", sizeof(buf));
 	fprintf(F, "node: {title: \"");
 	PRINT_ITEMID(tp, pos); fprintf(F, "\"");
-	fprintf(F, DEFAULT_ENUM_ITEM_ATTRIBUTE);
-	fprintf(F, "label: ");
+	fprintf(F, " label: ");
 	fprintf(F, "\"enum item %s\" " ENUM_ITEM_NODE_ATTR, get_id_str(id));
 	fprintf(F, "\n info1: \"value: %s\"}\n", buf);
 }
@@ -2029,12 +2111,16 @@ static void dump_enum_item(FILE *F, ir_type *tp, int pos)
 /**
  * Dumps a new style initializer.
  */
-static void dump_entity_initializer(FILE *F, const ir_entity *ent) {
-
+static void dump_entity_initializer(FILE *F, const ir_entity *ent)
+{
+	/* TODO */
+	(void) F;
+	(void) ent;
 }
 
 /** Dumps a type or entity and it's edges. */
-static void dump_type_info(type_or_ent tore, void *env) {
+static void dump_type_info(type_or_ent tore, void *env)
+{
 	FILE *F = env;
 	int i = 0;  /* to shutup gcc */
 
@@ -2056,33 +2142,23 @@ static void dump_type_info(type_or_ent tore, void *env) {
 				print_ent_ent_edge(F,ent, get_entity_overwrites(ent, i), 0, -1, ENT_OVERWRITES_EDGE_ATTR);
 		}
 		/* attached subgraphs */
-		if (const_entities && (get_entity_variability(ent) != variability_uninitialized)) {
-			if (is_atomic_entity(ent)) {
-				value = get_atomic_ent_value(ent);
-				if (value) {
-					print_ent_node_edge(F, ent, value, ENT_VALUE_EDGE_ATTR, i);
-					/* DDMN(value);  $$$ */
-					dump_const_expression(F, value);
-				}
-			}
-			if (is_compound_entity(ent)) {
-				if (has_entity_initializer(ent)) {
-					/* new style initializers */
-					dump_entity_initializer(F, ent);
-				} else {
-					/* old style compound entity values */
-					for (i = get_compound_ent_n_values(ent) - 1; i >= 0; --i) {
-						value = get_compound_ent_value(ent, i);
-						if (value) {
-							print_ent_node_edge(F, ent, value, ENT_VALUE_EDGE_ATTR, i);
-							dump_const_expression(F, value);
-							print_ent_ent_edge(F, ent, get_compound_ent_value_member(ent, i), 0, -1, ENT_CORR_EDGE_ATTR, i);
-							/*
-							fprintf(F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
-							ENT_CORR_EDGE_ATTR  "}\n", GET_ENTID(ent),
-							get_compound_ent_value_member(ent, i), i);
-							*/
-						}
+		if (const_entities) {
+			if (ent->initializer != NULL) {
+				/* new style initializers */
+				dump_entity_initializer(F, ent);
+			} else if (entity_has_compound_ent_values(ent)) {
+				/* old style compound entity values */
+				for (i = get_compound_ent_n_values(ent) - 1; i >= 0; --i) {
+					value = get_compound_ent_value(ent, i);
+					if (value) {
+						print_ent_node_edge(F, ent, value, ENT_VALUE_EDGE_ATTR, i);
+						dump_const_expression(F, value);
+						print_ent_ent_edge(F, ent, get_compound_ent_value_member(ent, i), 0, -1, ENT_CORR_EDGE_ATTR, i);
+						/*
+						fprintf(F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
+						ENT_CORR_EDGE_ATTR  "}\n", GET_ENTID(ent),
+						get_compound_ent_value_member(ent, i), i);
+						*/
 					}
 				}
 			}
@@ -2156,8 +2232,8 @@ typedef struct _h_env {
  * Dumps a class type node and a superclass edge.
  * If env->dump_ent dumps entities of classes and overwrites edges.
  */
-static void
-dump_class_hierarchy_node(type_or_ent tore, void *ctx) {
+static void dump_class_hierarchy_node(type_or_ent tore, void *ctx)
+{
 	h_env_t *env = ctx;
 	FILE *F = env->f;
 	int i = 0;  /* to shutup gcc */
@@ -2205,14 +2281,15 @@ dump_class_hierarchy_node(type_or_ent tore, void *ctx) {
 /*******************************************************************/
 
 /* dump out edges */
-static void
-dump_out_edge(ir_node *n, void *env) {
+static void dump_out_edge(ir_node *n, void *env)
+{
 	FILE *F = env;
 	int i;
 	for (i = get_irn_n_outs(n) - 1; i >= 0; --i) {
 		ir_node *succ = get_irn_out(n, i);
 		assert(succ);
-		fprintf(F, "edge: {sourcename: \"");
+		print_node_edge_kind(F, succ);
+		fprintf(F, "{sourcename: \"");
 		PRINT_NODEID(n);
 		fprintf(F, "\" targetname: \"");
 		PRINT_NODEID(succ);
@@ -2221,13 +2298,14 @@ dump_out_edge(ir_node *n, void *env) {
 	}
 }
 
-static inline void
-dump_loop_label(FILE *F, ir_loop *loop) {
+static inline void dump_loop_label(FILE *F, ir_loop *loop)
+{
 	fprintf(F, "loop %d, %d sons, %d nodes",
 	        get_loop_depth(loop), get_loop_n_sons(loop), get_loop_n_nodes(loop));
 }
 
-static inline void dump_loop_info(FILE *F, ir_loop *loop) {
+static inline void dump_loop_info(FILE *F, ir_loop *loop)
+{
 	fprintf(F, " info1: \"");
 	fprintf(F, " loop nr: %d", get_loop_loop_nr(loop));
 #ifdef DEBUG_libfirm   /* GL @@@ debug analyses */
@@ -2236,8 +2314,8 @@ static inline void dump_loop_info(FILE *F, ir_loop *loop) {
 	fprintf(F, "\"");
 }
 
-static inline void
-dump_loop_node(FILE *F, ir_loop *loop) {
+static inline void dump_loop_node(FILE *F, ir_loop *loop)
+{
 	fprintf(F, "node: {title: \"");
 	PRINT_LOOPID(loop);
 	fprintf(F, "\" label: \"");
@@ -2247,8 +2325,8 @@ dump_loop_node(FILE *F, ir_loop *loop) {
 	fprintf(F, "}\n");
 }
 
-static inline void
-dump_loop_node_edge(FILE *F, ir_loop *loop, int i) {
+static inline void dump_loop_node_edge(FILE *F, ir_loop *loop, int i)
+{
 	assert(loop);
 	fprintf(F, "edge: {sourcename: \"");
 	PRINT_LOOPID(loop);
@@ -2258,8 +2336,8 @@ dump_loop_node_edge(FILE *F, ir_loop *loop, int i) {
 	fprintf(F, "}\n");
 }
 
-static inline void
-dump_loop_son_edge(FILE *F, ir_loop *loop, int i) {
+static inline void dump_loop_son_edge(FILE *F, ir_loop *loop, int i)
+{
 	assert(loop);
 	fprintf(F, "edge: {sourcename: \"");
 	PRINT_LOOPID(loop);
@@ -2269,8 +2347,8 @@ dump_loop_son_edge(FILE *F, ir_loop *loop, int i) {
 	        get_loop_element_pos(loop, get_loop_son(loop, i)));
 }
 
-static
-void dump_loops(FILE *F, ir_loop *loop) {
+static void dump_loops(FILE *F, ir_loop *loop)
+{
 	int i;
 	/* dump this loop node */
 	dump_loop_node(F, loop);
@@ -2287,8 +2365,8 @@ void dump_loops(FILE *F, ir_loop *loop) {
 	}
 }
 
-static inline
-void dump_loop_nodes_into_graph(FILE *F, ir_graph *irg) {
+static inline void dump_loop_nodes_into_graph(FILE *F, ir_graph *irg)
+{
 	ir_loop *loop = get_irg_loop(irg);
 
 	if (loop != NULL) {
@@ -2305,7 +2383,8 @@ void dump_loop_nodes_into_graph(FILE *F, ir_graph *irg) {
 /**
  * dumps the VCG header
  */
-void dump_vcg_header(FILE *F, const char *name, const char *layout, const char *orientation) {
+void dump_vcg_header(FILE *F, const char *name, const char *layout, const char *orientation)
+{
 	int   i;
 	char *label;
 
@@ -2366,7 +2445,8 @@ void dump_vcg_header(FILE *F, const char *name, const char *layout, const char *
  * @param suffix1 first filename suffix
  * @param suffix2 second filename suffix
  */
-FILE *vcg_open(ir_graph *irg, const char *suffix1, const char *suffix2) {
+FILE *vcg_open(const ir_graph *irg, const char *suffix1, const char *suffix2)
+{
 	FILE *F;
 	const char *nm = get_irg_dump_name(irg);
 	int len = strlen(nm), i, j;
@@ -2412,7 +2492,8 @@ FILE *vcg_open(ir_graph *irg, const char *suffix1, const char *suffix2) {
  * @param name    prefix file name
  * @param suffix  filename suffix
  */
-FILE *vcg_open_name(const char *name, const char *suffix) {
+FILE *vcg_open_name(const char *name, const char *suffix)
+{
 	FILE *F;
 	char *fname;  /* filename to put the vcg information in */
 	int i, j, len = strlen(name);
@@ -2451,7 +2532,8 @@ FILE *vcg_open_name(const char *name, const char *suffix) {
 /**
  * Dumps the vcg file footer
  */
-void dump_vcg_footer(FILE *F) {
+void dump_vcg_footer(FILE *F)
+{
 	fprintf(F, "}\n");
 }
 
@@ -2479,9 +2561,12 @@ static void do_dump(ir_graph *irg, const char *suffix, const char *suffix_ip,
 
 	rem = current_ir_graph;
 	current_ir_graph = irg;
+	(void) suffix_ip;
+#ifdef INTERPROCEDURAL_VIEW
 	if (get_interprocedural_view())
 		suffix1 = suffix_ip;
 	else
+#endif
 		suffix1 = suffix_nonip;
 	current_ir_graph = rem;
 
@@ -2692,8 +2777,8 @@ void dump_ir_block_graph_w_types(ir_graph *irg, const char *suffix)
 /* The following routines dump a control flow graph.                   */
 /*---------------------------------------------------------------------*/
 
-static void
-dump_block_to_cfg(ir_node *block, void *env) {
+static void dump_block_to_cfg(ir_node *block, void *env)
+{
 	FILE *F = env;
 	int i, fl = 0;
 	ir_node *pred;
@@ -2800,7 +2885,8 @@ void dump_cfg(ir_graph *irg, const char *suffix)
 }
 
 
-static void descend_and_dump(FILE *F, ir_node *n, int depth, pset *mark_set) {
+static void descend_and_dump(FILE *F, ir_node *n, int depth, pset *mark_set)
+{
 	if (pset_find_ptr(mark_set, n))
 		return;
 
@@ -2819,7 +2905,8 @@ static void descend_and_dump(FILE *F, ir_node *n, int depth, pset *mark_set) {
 }
 
 static int subgraph_counter = 0;
-void dump_subgraph(ir_node *root, int depth, const char *suffix) {
+void dump_subgraph(ir_node *root, int depth, const char *suffix)
+{
 	FILE *F;
 	char buf[32];
 
@@ -2835,7 +2922,8 @@ void dump_subgraph(ir_node *root, int depth, const char *suffix) {
 	}
 }
 
-void dump_callgraph(const char *suffix) {
+void dump_callgraph(const char *suffix)
+{
 	FILE *F = vcg_open_name("Callgraph", suffix);
 
 	if (F != NULL) {
@@ -2871,7 +2959,8 @@ void dump_callgraph(const char *suffix) {
 
 #if 0
 /* Dump all irgs in interprocedural view to a single file. */
-void dump_all_cg_block_graph(const char *suffix) {
+void dump_all_cg_block_graph(const char *suffix)
+{
 	FILE *f = vcg_open_name("All_graphs", suffix);
 
 	if (f != NULL) {
@@ -2906,8 +2995,7 @@ void dump_all_cg_block_graph(const char *suffix) {
 /* the following routines dumps type information without any ir nodes. */
 /*---------------------------------------------------------------------*/
 
-void
-dump_type_graph(ir_graph *irg, const char *suffix)
+void dump_type_graph(ir_graph *irg, const char *suffix)
 {
 	FILE *f;
 
@@ -2935,8 +3023,7 @@ dump_type_graph(ir_graph *irg, const char *suffix)
 	}
 }
 
-void
-dump_all_types(const char *suffix)
+void dump_all_types(const char *suffix)
 {
 	FILE *f = vcg_open_name("All_types", suffix);
 	if (f != NULL) {
@@ -2949,8 +3036,7 @@ dump_all_types(const char *suffix)
 	}
 }
 
-void
-dump_class_hierarchy(int entities, const char *suffix)
+void dump_class_hierarchy(int entities, const char *suffix)
 {
 	FILE *f = vcg_open_name("class_hierarchy", suffix);
 
@@ -2975,19 +3061,57 @@ dump_class_hierarchy(int entities, const char *suffix)
 /*  dump_ir_graph_w_types                                              */
 /*---------------------------------------------------------------------*/
 
-void dump_all_ir_graphs(dump_graph_func *dmp_grph, const char *suffix) {
+void dump_all_ir_graphs(dump_graph_func *dmp_grph, const char *suffix)
+{
 	int i;
 	for (i = get_irp_n_irgs() - 1; i >= 0; --i)
 		dmp_grph(get_irp_irg(i), suffix);
 }
 
+struct pass_t {
+	ir_prog_pass_t  pass;
+	dump_graph_func *dump_graph;
+	char            suffix[1];
+};
+
+/**
+ * Wrapper around dump_all_ir_graphs().
+ */
+static int dump_all_ir_graphs_wrapper(ir_prog *irp, void *context)
+{
+	struct pass_t *pass = context;
+
+	(void)irp;
+	dump_all_ir_graphs(pass->dump_graph, pass->suffix);
+	return 0;
+}
+
+ir_prog_pass_t *dump_all_ir_graph_pass(const char *name,
+                                       dump_graph_func *dump_graph,
+                                       const char *suffix)
+{
+	size_t         len   = strlen(suffix);
+	struct pass_t  *pass = xmalloc(sizeof(*pass) + len);
+	ir_prog_pass_t *res  = def_prog_pass_constructor(
+		&pass->pass, name ? name : "dump_all_graphs", dump_all_ir_graphs_wrapper);
+
+	/* this pass does not change anything, so neither dump nor verify is needed. */
+	res->dump_irprog   = ir_prog_no_dump;
+	res->verify_irprog = ir_prog_no_verify;
+
+	pass->dump_graph = dump_graph;
+	strcpy(pass->suffix, suffix);
+
+	return res;
+}
 
 /*--------------------------------------------------------------------------------*
  * Dumps a stand alone loop graph with firm nodes which belong to one loop node   *
  * packed together in one subgraph/box                                            *
  *--------------------------------------------------------------------------------*/
 
-void dump_loops_standalone(FILE *F, ir_loop *loop) {
+static void dump_loops_standalone(FILE *F, ir_loop *loop)
+{
 	int i = 0, loop_node_started = 0, son_number = 0, first = 0;
 	loop_element le;
 	ir_loop *son = NULL;
@@ -3093,7 +3217,8 @@ void dump_loop_tree(ir_graph *irg, const char *suffix)
 	}
 }
 
-void dump_callgraph_loop_tree(const char *suffix) {
+void dump_callgraph_loop_tree(const char *suffix)
+{
 	FILE *F;
 	F = vcg_open_name("Callgraph_looptree", suffix);
 	dump_vcg_header(F, "callgraph looptree", "Tree", "top_to_bottom");
@@ -3107,7 +3232,8 @@ void dump_callgraph_loop_tree(const char *suffix) {
 /* Dumps the firm nodes in the loop tree to a graph along with the loop nodes.*/
 /*----------------------------------------------------------------------------*/
 
-void collect_nodeloop(FILE *F, ir_loop *loop, eset *loopnodes) {
+static void collect_nodeloop(FILE *F, ir_loop *loop, eset *loopnodes)
+{
 	int i, son_number = 0, node_number = 0;
 
 	if (dump_loop_information_flag) dump_loop_node(F, loop);
@@ -3125,10 +3251,12 @@ void collect_nodeloop(FILE *F, ir_loop *loop, eset *loopnodes) {
 	}
 }
 
-void collect_nodeloop_external_nodes(ir_loop *loop, eset *loopnodes, eset *extnodes) {
+static void collect_nodeloop_external_nodes(ir_loop *loop, eset *loopnodes,
+                                            eset *extnodes)
+{
 	int i, j, start;
 
-	for(i = 0; i < get_loop_n_elements(loop); i++) {
+	for (i = 0; i < get_loop_n_elements(loop); i++) {
 		loop_element le = get_loop_element(loop, i);
 		if (*(le.kind) == k_ir_loop) {
 			/* Recur */
@@ -3149,7 +3277,8 @@ void collect_nodeloop_external_nodes(ir_loop *loop, eset *loopnodes, eset *extno
 	}
 }
 
-void dump_loop(ir_loop *l, const char *suffix) {
+void dump_loop(ir_loop *l, const char *suffix)
+{
 	FILE *F;
 	char name[50];