+/**
+ * @file
+ * @brief Write vcg representation of firm to file.
+ * @author Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Hubert Schmidt
+ * @version $Id$
+ */
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#include <stdarg.h>
+
+#include "firm_common_t.h"
+
+#include "list.h"
+
+#include "irnode.h"
+#include "irgraph.h"
+#include "irprog_t.h"
+#include "entity_t.h"
+#include "irop.h"
+
+#include "irdump_t.h"
+
+#include "irgwalk.h"
+#include "tv_t.h"
+#include "irouts.h"
+#include "irdom.h"
+#include "irloop_t.h"
+#include "callgraph.h"
+#include "irextbb_t.h"
+#include "irhooks.h"
+#include "dbginfo_t.h"
+#include "irtools.h"
+
+#include "irvrfy.h"
+
+#include "error.h"
+#include "array.h"
+#include "pmap.h"
+#include "eset.h"
+#include "pset.h"
+
+#if DO_HEAPANALYSIS
+extern void dump_irn_chi_term(FILE *FL, ir_node *n);
+extern void dump_irn_state(FILE *FL, ir_node *n);
+extern int get_opt_dump_abstvals(void);
+typedef unsigned long SeqNo;
+extern SeqNo get_Block_seqno(ir_node *n);
+#endif
+
+/* basis for a color range for vcg */
+static int n_colors = 0;
+static int base_color = 0;
+
+/** Dump only irgs with names that start with this string */
+static ident *dump_file_filter_id = NULL;
+
+#define ERROR_TXT "<ERROR>"
+
+/*******************************************************************/
+/* flags to steer output */
+/*******************************************************************/
+
+/** An option to turn off edge labels */
+static int edge_label = 1;
+/** An option to turn off dumping values of constant entities */
+static int const_entities = 1;
+/** An option to dump the keep alive edges */
+static int dump_keepalive = 0;
+/** An option to dump ld_names instead of names. */
+static int dump_ld_name = 1;
+/** Compiler options to dump analysis information in dump_ir_graph */
+static int dump_out_edge_flag = 0;
+static int dump_loop_information_flag = 0;
+static int dump_backedge_information_flag = 1;
+static int dump_const_local = 0;
+static int dump_node_idx_labels = 0;
+/** An option to dump all graph anchors */
+static int dump_anchors = 0;
+
+int dump_dominator_information_flag = 0;
+int opt_dump_analysed_type_info = 1;
+int opt_dump_pointer_values_to_info = 0; /* default off: for test compares!! */
+
+static dumper_colors overrule_nodecolor = ird_color_default;
+
+/** The vcg node attribute hook. */
+static DUMP_IR_GRAPH_FUNC dump_ir_graph_hook = NULL;
+/** The vcg node attribute hook. */
+static DUMP_NODE_VCGATTR_FUNC dump_node_vcgattr_hook = NULL;
+/** The vcg edge attribute hook. */
+static DUMP_EDGE_VCGATTR_FUNC dump_edge_vcgattr_hook = NULL;
+/** The vcg dump block edge hook */
+static DUMP_NODE_EDGE_FUNC dump_block_edge_hook = NULL;
+/** The vcg dump node edge hook. */
+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) {
+ dump_node_edge_hook = func;
+}
+
+/* Get the additional edge dump hook. */
+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) {
+ dump_block_edge_hook = func;
+}
+
+/* Get the additional block edge dump hook. */
+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) {
+ dump_ir_graph_hook = hook;
+}
+
+/* set the node attribute 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) {
+ 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.
+ */
+int get_opt_dump_const_local(void) {
+ if (!dump_out_edge_flag && !dump_loop_information_flag)
+ return dump_const_local;
+ else
+ return 0;
+}
+
+/* Set a prefix filter for output functions. */
+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) {
+ 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) {
+ 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) {
+ edge_label = 0;
+}
+
+void dump_consts_local(int flag) {
+ dump_const_local = flag;
+}
+
+void dump_node_idx_label(int flag) {
+ dump_node_idx_labels = flag;
+}
+
+void dump_constant_entity_values(int flag) {
+ const_entities = flag;
+}
+
+void dump_keepalive_edges(int flag) {
+ dump_keepalive = flag;
+}
+
+int get_opt_dump_keepalive_edges(void) {
+ return dump_keepalive;
+}
+
+void dump_out_edges(int flag) {
+ dump_out_edge_flag = flag;
+}
+
+void dump_dominator_information(int flag) {
+ dump_dominator_information_flag = flag;
+}
+
+void dump_loop_information(int flag) {
+ dump_loop_information_flag = flag;
+}
+
+void dump_backedge_information(int flag) {
+ dump_backedge_information_flag = flag;
+}
+
+/* Dump the information of type field specified in ana/irtypeinfo.h.
+ * 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) {
+ opt_dump_analysed_type_info = flag;
+}
+
+void dump_pointer_values_to_info(int flag) {
+ opt_dump_pointer_values_to_info = flag;
+}
+
+void dump_ld_names(int flag) {
+ dump_ld_name = flag;
+}
+
+void dump_all_anchors(int flag) {
+ dump_anchors = flag;
+}
+
+/* -------------- some extended helper functions ----------------- */
+
+/**
+ * returns the name of a mode or <ERROR> if mode is NOT a mode object.
+ * in the later case, sets bad
+ */
+const char *get_mode_name_ex(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(ir_type *tp, int *bad) {
+ if (is_type(tp))
+ return get_type_name(tp);
+ *bad |= 1;
+ return ERROR_TXT;
+}
+
+/**
+ * printf the VCG color to a file
+ */
+static void print_vcg_color(FILE *F, dumper_colors color) {
+ static const char *color_names[32] = {
+ "white", "blue", "red", "green",
+ "yellow", "magenta", "cyan", "darkgray",
+ "darkblue", "darkred", "darkgreen", "darkyellow",
+ "darkmagenta", "darkcyan", "gold", "lightgray",
+ "lightblue", "lightred", "lightgreen", "lightyellow",
+ "lightmagenta", "lightcyan", "lilac", "turquoise",
+ "aquamarine", "khaki", "purple", "yellowgreen",
+ "pink", "orange", "orchid", "black"
+ };
+
+ if (color != ird_color_default)
+ fprintf(F, "color:%s", color_names[color]);
+}
+
+/**
+ * prints the edge from a type S to a type T with additional info fmt, ...
+ * to the file F
+ */
+static void print_type_type_edge(FILE *F, ir_type *S, ir_type *T, const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ fprintf(F, "edge: { sourcename: "); PRINT_TYPEID(S);
+ fprintf(F, " targetname: "); PRINT_TYPEID(T);
+ vfprintf(F, fmt, ap);
+ fprintf(F,"}\n");
+ va_end(ap);
+}
+
+/**
+ * prints the edge from a type T to an entity E with additional info fmt, ...
+ * to the file F
+ */
+static void print_type_ent_edge(FILE *F, ir_type *T, ir_entity *E, const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ fprintf(F, "edge: { sourcename: "); PRINT_TYPEID(T);
+ fprintf(F, " targetname: \""); PRINT_ENTID(E); fprintf(F, "\"");
+ vfprintf(F, fmt, ap);
+ fprintf(F, "}\n");
+ va_end(ap);
+}
+
+/**
+ * prints the edge from an entity E to an entity T with additional info fmt, ...
+ * to the file F
+ */
+static void print_ent_ent_edge(FILE *F, ir_entity *E, ir_entity *T, int backedge, const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ if (backedge)
+ fprintf(F, "backedge: { sourcename: \"");
+ else
+ fprintf(F, "edge: { sourcename: \"");
+ PRINT_ENTID(E);
+ fprintf(F, "\" targetname: \""); PRINT_ENTID(T); fprintf(F, "\"");
+ vfprintf(F, fmt, ap);
+ fprintf(F, "}\n");
+ va_end(ap);
+}
+
+/**
+ * prints the edge from an entity E to a type T with additional info fmt, ...
+ * to the file F
+ */
+static void print_ent_type_edge(FILE *F, ir_entity *E, ir_type *T, const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ fprintf(F, "edge: { sourcename: \""); PRINT_ENTID(E);
+ fprintf(F, "\" targetname: "); PRINT_TYPEID(T);
+ vfprintf(F, fmt, ap);
+ fprintf(F,"}\n");
+ va_end(ap);
+}
+
+/**
+ * prints the edge from a node N to a type T with additional info fmt, ...
+ * to the file F
+ */
+static void print_node_type_edge(FILE *F, const ir_node *N, ir_type *T, const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ fprintf(F, "edge: { sourcename: \""); PRINT_NODEID(N);
+ fprintf(F, "\" targetname: "); PRINT_TYPEID(T);
+ vfprintf(F, fmt, ap);
+ fprintf(F,"}\n");
+ va_end(ap);
+}
+
+/**
+ * prints the edge from a node N to an entity E with additional info fmt, ...
+ * to the file F
+ */
+static void print_node_ent_edge(FILE *F, const ir_node *N, ir_entity *E, const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ fprintf(F, "edge: { sourcename: \""); PRINT_NODEID(N);
+ fprintf(F, "\" targetname: \""); PRINT_ENTID(E);
+ fprintf(F, "\"");
+ vfprintf(F, fmt, ap);
+ fprintf(F,"}\n");
+ va_end(ap);
+}
+
+/**
+ * prints the edge from an entity E to a node N with additional info fmt, ...
+ * to the file F
+ */
+static void print_ent_node_edge(FILE *F, ir_entity *E, const ir_node *N, const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ fprintf(F, "edge: { sourcename: \""); PRINT_ENTID(E);
+ fprintf(F, "\" targetname: \""); PRINT_NODEID(N); fprintf(F, "\"");
+ vfprintf(F, fmt, ap);
+ fprintf(F,"}\n");
+ va_end(ap);
+}
+
+/**
+ * prints the edge from a type E to an enumeration item item with additional info fmt, ...
+ * to the file F
+ */
+static void print_enum_item_edge(FILE *F, ir_type *E, int item, const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ fprintf(F, "edge: { sourcename: "); PRINT_TYPEID(E);
+ fprintf(F, " targetname: \""); PRINT_ITEMID(E, item); fprintf(F, "\" ");
+ vfprintf(F, fmt, ap);
+ fprintf(F,"}\n");
+ va_end(ap);
+}
+
+/*-----------------------------------------------------------------*/
+/* global and ahead declarations */
+/*-----------------------------------------------------------------*/
+
+static void dump_whole_node(ir_node *n, void *env);
+static INLINE void dump_loop_nodes_into_graph(FILE *F, ir_graph *irg);
+
+/*-----------------------------------------------------------------*/
+/* Helper functions. */
+/*-----------------------------------------------------------------*/
+
+/**
+ * This map is used as a private link attr to be able to call dumper
+ * anywhere without destroying link fields.
+ */
+static pmap *irdump_link_map = NULL;
+
+/** NOT A STANDARD LIBFIRM INIT METHOD
+ *
+ * We do not want to integrate dumping into libfirm, i.e., if the dumpers
+ * are off, we want to have as few interferences as possible. Therefore the
+ * initialization is performed lazily and not called from within init_firm.
+ *
+ * Creates the link attribute map. */
+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();
+ if (!dump_file_filter_id)
+ dump_file_filter_id = new_id_from_str("");
+}
+
+/**
+ * Returns the private link field.
+ */
+static void *ird_get_irn_link(ir_node *n) {
+ void *res = NULL;
+ if (!irdump_link_map) return NULL;
+
+ if (pmap_contains(irdump_link_map, (void *)n))
+ res = pmap_get(irdump_link_map, (void *)n);
+ return res;
+}
+
+/**
+ * Sets the private link field.
+ */
+static void ird_set_irn_link(ir_node *n, void *x) {
+ if (!irdump_link_map)
+ init_irdump();
+ pmap_insert(irdump_link_map, (void *)n, x);
+}
+
+/**
+ * Gets the private link field of an irg.
+ */
+static void *ird_get_irg_link(ir_graph *irg) {
+ void *res = NULL;
+ if (!irdump_link_map) return NULL;
+
+ if (pmap_contains(irdump_link_map, (void *)irg))
+ res = pmap_get(irdump_link_map, (void *)irg);
+ return res;
+}
+
+/**
+ * Sets the private link field of an irg.
+ */
+static void ird_set_irg_link(ir_graph *irg, void *x) {
+ if (!irdump_link_map) init_irdump();
+ pmap_insert(irdump_link_map, (void *)irg, x);
+}
+
+/**
+ * Walker, clears the private link field.
+ */
+static void clear_link(ir_node * node, void * env) {
+ (void) env;
+ ird_set_irn_link(node, NULL);
+}
+
+/**
+ * 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(ir_entity *ent, int dump_ld_name) {
+ if (!ent)
+ return "<NULL entity>";
+ if (dump_ld_name) {
+ /* Don't use get_entity_ld_ident (ent) as it computes the mangled name! */
+ if (ent->ld_name) return get_id_str(ent->ld_name);
+ }
+ return get_id_str(ent->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(ir_entity *ent) {
+ return _get_ent_dump_name(ent, dump_ld_name);
+}
+
+/* Returns the name of an IRG. */
+const char *get_irg_dump_name(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);
+}
+
+/**
+ * Returns non-zero if a node is in floating state.
+ */
+static int node_floats(ir_node *n) {
+ return ((get_irn_pinned(n) == op_pin_state_floats) &&
+ (get_irg_pinned(current_ir_graph) == op_pin_state_floats));
+}
+
+/**
+ * Walker that visits the anchors
+ */
+static void ird_walk_graph(ir_graph *irg, irg_walk_func *pre, irg_walk_func *post, void *env) {
+ if (dump_anchors) {
+ irg_walk_anchors(irg, pre, post, env);
+ } else {
+ irg_walk_graph(irg, pre, post, env);
+ }
+}
+
+/**
+ * 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) {
+ (void) env;
+ if (is_Block(node)
+ || node_floats(node)
+ || get_irn_op(node) == op_Bad
+ || get_irn_op(node) == op_Unknown
+ || get_irn_op(node) == op_NoMem) {
+ ir_node ** arr = (ir_node **) ird_get_irg_link(get_irn_irg(node));
+ if (!arr) arr = NEW_ARR_F(ir_node *, 0);
+ ARR_APP1(ir_node *, arr, node);
+ ird_set_irg_link(get_irn_irg(node), arr); /* arr is an l-value, APP_ARR might change it! */
+ } else {
+ ir_node * block = get_nodes_block(node);
+
+ if (is_Bad(block)) {
+ /* this node is in a Bad block, so we must place it into the graph's list */
+ ir_node ** arr = (ir_node **) ird_get_irg_link(get_irn_irg(node));
+ if (!arr) arr = NEW_ARR_F(ir_node *, 0);
+ ARR_APP1(ir_node *, arr, node);
+ ird_set_irg_link(get_irn_irg(node), arr); /* arr is an l-value, APP_ARR might change it! */
+ } else {
+ ird_set_irn_link(node, ird_get_irn_link(block));
+ ird_set_irn_link(block, node);
+ }
+ }
+}
+
+/** Construct lists to walk ir block-wise.
+ *
+ * Collects all blocks, nodes not op_pin_state_pinned,
+ * Bad, NoMem and Unknown into a flexible array in link field of
+ * irg they belong to. Sets the irg link field to NULL in all
+ * graphs not visited.
+ * Free the list with DEL_ARR_F().
+ */
+static ir_node **construct_block_lists(ir_graph *irg) {
+ int i;
+ int rem_view = get_interprocedural_view();
+ int walk_flag = using_visited(irg);
+ ir_graph *rem = current_ir_graph;
+
+ current_ir_graph = irg;
+
+ if(walk_flag)
+ clear_using_visited(current_ir_graph);
+
+ for (i = get_irp_n_irgs() - 1; i >= 0; --i)
+ ird_set_irg_link(get_irp_irg(i), NULL);
+
+ ird_walk_graph(current_ir_graph, clear_link, collect_node, current_ir_graph);
+
+ /* Collect also EndReg and EndExcept. We do not want to change the walker. */
+ set_interprocedural_view(0);
+
+ set_irg_visited(current_ir_graph, get_irg_visited(current_ir_graph)-1);
+ irg_walk(get_irg_end_reg(current_ir_graph), clear_link, collect_node, current_ir_graph);
+ set_irg_visited(current_ir_graph, get_irg_visited(current_ir_graph)-1);
+ irg_walk(get_irg_end_except(current_ir_graph), clear_link, collect_node, current_ir_graph);
+
+ set_interprocedural_view(rem_view);
+
+ if(walk_flag)
+ set_using_visited(current_ir_graph);
+
+ current_ir_graph = rem;
+ return ird_get_irg_link(irg);
+}
+
+typedef struct _list_tuple {
+ ir_node **blk_list;
+ ir_extblk **extbb_list;
+} list_tuple;
+
+/** Construct lists to walk IR extended block-wise.
+ * Free the lists in the tuple with DEL_ARR_F().
+ * Sets the irg link field to NULL in all
+ * graphs not visited.
+ */
+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;
+ list_tuple *lists = xmalloc(sizeof(*lists));
+
+ current_ir_graph = irg;
+
+ lists->blk_list = NEW_ARR_F(ir_node *, 0);
+ lists->extbb_list = NEW_ARR_F(ir_extblk *, 0);
+
+ inc_irg_block_visited(irg);
+ for (i = ARR_LEN(blk_list) - 1; i >= 0; --i) {
+ ir_extblk *ext;
+
+ if (is_Block(blk_list[i])) {
+ ext = get_Block_extbb(blk_list[i]);
+
+ if (extbb_not_visited(ext)) {
+ ARR_APP1(ir_extblk *, lists->extbb_list, ext);
+ mark_extbb_visited(ext);
+ }
+ } else
+ ARR_APP1(ir_node *, lists->blk_list, blk_list[i]);
+ }
+ DEL_ARR_F(blk_list);
+
+ current_ir_graph = rem;
+ ird_set_irg_link(irg, lists);
+ return lists;
+}
+
+/*-----------------------------------------------------------------*/
+/* Routines to dump information about a single ir node. */
+/*-----------------------------------------------------------------*/
+
+/*
+ * dump the name of a node n to the File F.
+ */
+int dump_node_opcode(FILE *F, ir_node *n)
+{
+ int bad = 0;
+ const ir_op_ops *ops = get_op_ops(get_irn_op(n));
+
+ /* call the dump_node operation if available */
+ if (ops->dump_node)
+ return ops->dump_node(n, F, dump_node_opcode_txt);
+
+ /* implementation for default nodes */
+ switch (get_irn_opcode(n)) {
+
+ case iro_Const: {
+ int res;
+ char buf[1024];
+ res = tarval_snprintf(buf, sizeof(buf), get_Const_tarval(n));
+ assert(res < (int) sizeof(buf) && "buffer to small for tarval_snprintf");
+ fprintf(F, buf);
+ } break;
+
+ 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;
+ case symconst_ofs_ent:
+ 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));
+ break;
+ case symconst_type_size:
+ fprintf(F, "SymC %s size", get_type_name_ex(get_SymConst_type(n), &bad));
+ break;
+ case symconst_type_align:
+ fprintf(F, "SymC %s align", get_type_name_ex(get_SymConst_type(n), &bad));
+ 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));
+ break;
+ }
+ } break;
+
+ case iro_Filter: {
+ if (!get_interprocedural_view())
+ fprintf(F, "Proj'");
+ else
+ goto default_case;
+ } break;
+
+ case iro_Proj: {
+ ir_node *pred = get_Proj_pred(n);
+
+ if (get_irn_opcode(pred) == iro_Cond
+ && get_Proj_proj(n) == get_Cond_defaultProj(pred)
+ && get_irn_mode(get_Cond_selector(pred)) != mode_b)
+ fprintf(F, "defProj");
+ else
+ goto default_case;
+ } break;
+ case iro_Start:
+ case iro_End:
+ case iro_EndExcept:
+ case iro_EndReg: {
+ if (get_interprocedural_view()) {
+ fprintf(F, "%s %s", get_irn_opname(n), get_ent_dump_name(get_irg_entity(get_irn_irg(n))));
+ break;
+ } else
+ goto default_case;
+ }
+ case iro_CallBegin: {
+ ir_node *addr = get_CallBegin_ptr(n);
+ ir_entity *ent = NULL;
+ if (get_irn_op(addr) == op_Sel)
+ ent = get_Sel_entity(addr);
+ else if ((get_irn_op(addr) == op_SymConst) && (get_SymConst_kind(addr) == symconst_addr_ent))
+ ent = get_SymConst_entity(addr);
+ fprintf(F, "%s", get_irn_opname(n));
+ if (ent) fprintf(F, " %s", get_entity_name(ent));
+ break;
+ }
+ case iro_Load:
+ if (get_Load_align(n) == align_non_aligned)
+ fprintf(F, "ua");
+ fprintf(F, "%s[%s]", get_irn_opname(n), get_mode_name_ex(get_Load_mode(n), &bad));
+ break;
+ case iro_Store:
+ if (get_Store_align(n) == align_non_aligned)
+ fprintf(F, "ua");
+ fprintf(F, "%s", get_irn_opname(n));
+ break;
+ case iro_Block:
+ fprintf(F, "%s%s", is_Block_dead(n) ? "Dead " : "", get_irn_opname(n));
+ break;
+ case iro_Conv:
+ if (get_Conv_strict(n))
+ fprintf(F, "strict");
+ fprintf(F, "%s", get_irn_opname(n));
+ break;
+ case iro_Div:
+ fprintf(F, "%s[%s]", get_irn_opname(n), get_mode_name_ex(get_Div_resmode(n), &bad));
+ break;
+ case iro_Mod:
+ fprintf(F, "%s[%s]", get_irn_opname(n), get_mode_name_ex(get_Mod_resmode(n), &bad));
+ break;
+ case iro_DivMod:
+ fprintf(F, "%s[%s]", get_irn_opname(n), get_mode_name_ex(get_DivMod_resmode(n), &bad));
+ break;
+
+ default:
+default_case:
+ fprintf(F, "%s", get_irn_opname(n));
+
+ } /* end switch */
+ return bad;
+}
+
+/**
+ * Dump the mode of a node n to a file F.
+ * Ignore modes that are "always known".
+ */
+static int dump_node_mode(FILE *F, ir_node *n)
+{
+ int bad = 0;
+ const ir_op_ops *ops = get_op_ops(get_irn_op(n));
+ ir_opcode iro;
+
+ /* call the dump_node operation if available */
+ if (ops->dump_node)
+ return ops->dump_node(n, F, dump_node_mode_txt);
+
+ /* default implementation */
+ iro = get_irn_opcode(n);
+ switch (iro) {
+ case iro_SymConst:
+ case iro_Sel:
+ case iro_End:
+ case iro_Return:
+ case iro_Free:
+ case iro_Sync:
+ case iro_Jmp:
+ case iro_NoMem:
+ break;
+ default: {
+ ir_mode *mode = get_irn_mode(n);
+
+ if (mode && mode != mode_BB && mode != mode_ANY && mode != mode_BAD &&
+ (mode != mode_T || iro == iro_Proj))
+ fprintf(F, "%s", get_mode_name_ex(mode, &bad));
+ }
+ }
+
+ return bad;
+}
+
+/**
+ * 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) {
+ 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
+ fprintf(F, "[] ");
+ }
+ }
+ return bad;
+}
+
+typedef struct _pns_lookup {
+ long nr; /**< the proj number */
+ const char *name; /**< the name of the Proj */
+} pns_lookup_t;
+
+typedef struct _proj_lookup {
+ ir_opcode code; /**< the opcode of the Proj predecessor */
+ unsigned num_data; /**< number of data entries */
+ const pns_lookup_t *data; /**< the data */
+} proj_lookup_t;
+
+#define ARR_SIZE(a) (sizeof(a)/sizeof(a[0]))
+
+/** the lookup table for Proj(Start) names */
+static const pns_lookup_t start_lut[] = {
+#define X(a) { pn_Start_##a, #a }
+ X(X_initial_exec),
+ X(P_frame_base),
+ X(P_globals),
+ X(P_tls),
+ X(T_args),
+ X(P_value_arg_base)
+#undef X
+};
+
+/** the lookup table for Proj(Cond) names */
+static const pns_lookup_t cond_lut[] = {
+#define X(a) { pn_Cond_##a, #a }
+ X(false),
+ X(true)
+#undef X
+};
+
+/** 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(X_regular),
+ X(X_except),
+ X(T_result),
+ X(M_except),
+ X(P_value_res_base)
+#undef X
+};
+
+/** the lookup table for Proj(Quot) names */
+static const pns_lookup_t quot_lut[] = {
+#define X(a) { pn_Quot_##a, #a }
+ X(M),
+ X(X_regular),
+ X(X_except),
+ X(res)
+#undef X
+};
+
+/** the lookup table for Proj(DivMod) names */
+static const pns_lookup_t divmod_lut[] = {
+#define X(a) { pn_DivMod_##a, #a }
+ X(M),
+ X(X_regular),
+ X(X_except),
+ X(res_div),
+ X(res_mod)
+#undef X
+};
+
+/** the lookup table for Proj(Div) names */
+static const pns_lookup_t div_lut[] = {
+#define X(a) { pn_Div_##a, #a }
+ X(M),
+ X(X_regular),
+ X(X_except),
+ X(res)
+#undef X
+};
+
+/** the lookup table for Proj(Mod) names */
+static const pns_lookup_t mod_lut[] = {
+#define X(a) { pn_Mod_##a, #a }
+ X(M),
+ X(X_regular),
+ X(X_except),
+ X(res)
+#undef X
+};
+
+/** the lookup table for Proj(Load) names */
+static const pns_lookup_t load_lut[] = {
+#define X(a) { pn_Load_##a, #a }
+ X(M),
+ X(X_regular),
+ X(X_except),
+ X(res)
+#undef X
+};
+
+/** the lookup table for Proj(Store) names */
+static const pns_lookup_t store_lut[] = {
+#define X(a) { pn_Store_##a, #a }
+ X(M),
+ X(X_regular),
+ X(X_except)
+#undef X
+};
+
+/** the lookup table for Proj(Alloc) names */
+static const pns_lookup_t alloc_lut[] = {
+#define X(a) { pn_Alloc_##a, #a }
+ X(M),
+ X(X_regular),
+ X(X_except),
+ X(res)
+#undef X
+};
+
+/** the lookup table for Proj(CopyB) names */
+static const pns_lookup_t copyb_lut[] = {
+#define X(a) { pn_CopyB_##a, #a }
+ X(M),
+ X(X_regular),
+ X(X_except),
+ X(M_except)
+#undef X
+};
+
+/** the lookup table for Proj(InstOf) names */
+static const pns_lookup_t instof_lut[] = {
+#define X(a) { pn_InstOf_##a, #a }
+ X(M),
+ X(X_regular),
+ X(X_except),
+ X(res),
+ X(M_except),
+#undef X
+};
+
+/** the lookup table for Proj(Raise) names */
+static const pns_lookup_t raise_lut[] = {
+#define X(a) { pn_Raise_##a, #a }
+ X(M),
+ X(X),
+#undef X
+};
+
+/** the lookup table for Proj(Bound) names */
+static const pns_lookup_t bound_lut[] = {
+#define X(a) { pn_Bound_##a, #a }
+ X(M),
+ X(X_regular),
+ X(X_except),
+ X(res),
+#undef X
+};
+
+/** the Proj lookup table */
+static const proj_lookup_t proj_lut[] = {
+#define E(a) ARR_SIZE(a), a
+ { iro_Start, E(start_lut) },
+ { iro_Cond, E(cond_lut) },
+ { iro_Call, E(call_lut) },
+ { iro_Quot, E(quot_lut) },
+ { iro_DivMod, E(divmod_lut) },
+ { iro_Div, E(div_lut) },
+ { iro_Mod, E(mod_lut) },
+ { iro_Load, E(load_lut) },
+ { iro_Store, E(store_lut) },
+ { iro_Alloc, E(alloc_lut) },
+ { iro_CopyB, E(copyb_lut) },
+ { iro_InstOf, E(instof_lut) },
+ { iro_Raise, E(raise_lut) },
+ { iro_Bound, E(bound_lut) }
+#undef E
+};
+
+/**
+ * Dump additional node attributes of some nodes to a file F.
+ */
+static int
+dump_node_nodeattr(FILE *F, ir_node *n)
+{
+ int bad = 0;
+ ir_node *pred;
+ ir_opcode code;
+ long proj_nr;
+ const ir_op_ops *ops = get_op_ops(get_irn_op(n));
+
+ /* call the dump_node operation if available */
+ if (ops->dump_node)
+ 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_Proj:
+ pred = get_Proj_pred(n);
+ proj_nr = get_Proj_proj(n);
+handle_lut:
+ code = get_irn_opcode(pred);
+
+ if (code == iro_Cmp)
+ fprintf(F, "%s ", get_pnc_string(get_Proj_proj(n)));
+ else if (code == iro_Proj && get_irn_opcode(get_Proj_pred(pred)) == iro_Start)
+ fprintf(F, "Arg %ld ", proj_nr);
+ else if (code == iro_Cond && get_irn_mode(get_Cond_selector(pred)) != mode_b)
+ fprintf(F, "%ld ", proj_nr);
+ else {
+ unsigned i, j, f = 0;
+
+ for (i = 0; i < ARR_SIZE(proj_lut); ++i) {
+ if (code == proj_lut[i].code) {
+ for (j = 0; j < proj_lut[i].num_data; ++j) {
+ if (proj_nr == proj_lut[i].data[j].nr) {
+ fprintf(F, "%s ", proj_lut[i].data[j].name);
+ f = 1;
+ break;
+ }
+ }
+ break;
+ }
+ }
+ if (! f)
+ fprintf(F, "%ld ", proj_nr);
+ if (code == iro_Cond && get_Cond_jmp_pred(pred) != COND_JMP_PRED_NONE) {
+ if (proj_nr == pn_Cond_false && get_Cond_jmp_pred(pred) == COND_JMP_PRED_FALSE)
+ fprintf(F, "PRED ");
+ if (proj_nr == pn_Cond_true && get_Cond_jmp_pred(pred) == COND_JMP_PRED_TRUE)
+ fprintf(F, "PRED ");
+ }
+ }
+ break;
+ case iro_Filter:
+ proj_nr = get_Filter_proj(n);
+ if (! get_interprocedural_view()) {
+ /* it's a Proj' */
+ pred = get_Filter_pred(n);
+ goto handle_lut;
+ } else
+ 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));
+ 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));
+ break;
+
+ default:
+ ;
+ } /* end switch */
+
+ return bad;
+}
+
+#include <math.h>
+#include "execution_frequency.h"
+
+static void dump_node_ana_vals(FILE *F, ir_node *n) {
+ return;
+ fprintf(F, " %lf*(%2.0lf + %2.0lf) = %2.0lf ",
+ get_irn_exec_freq(n),
+ get_irg_method_execution_frequency(get_irn_irg(n)),
+ pow(5, get_irg_recursion_depth(get_irn_irg(n))),
+ get_irn_exec_freq(n) * (get_irg_method_execution_frequency(get_irn_irg(n)) + pow(5, get_irg_recursion_depth(get_irn_irg(n))))
+ );
+}
+
+
+/* Dumps a node label without the enclosing ". */
+int dump_node_label(FILE *F, ir_node *n) {
+ int bad = 0;
+
+ bad |= dump_node_opcode(F, n);
+ 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 {
+ fprintf(F, "%ld", get_irn_node_nr(n));
+ }
+
+ return bad;
+}
+
+
+/**
+ * Dumps the attributes of a node n into the file F.
+ * Currently this is only the color of a node.
+ */
+static void dump_node_vcgattr(FILE *F, ir_node *node, ir_node *local, int bad)
+{
+ ir_node *n;
+
+ if (bad) {
+ print_vcg_color(F, ird_color_red);
+ return;
+ }
+
+ if (dump_node_vcgattr_hook)
+ if (dump_node_vcgattr_hook(F, node, local))
+ return;
+
+ n = local ? local : node;
+
+ if (overrule_nodecolor != ird_color_default) {
+ print_vcg_color(F, overrule_nodecolor);
+ return;
+ }
+
+ switch (get_irn_opcode(n)) {
+ case iro_Start:
+ case iro_EndReg:
+ /* fall through */
+ case iro_EndExcept:
+ /* fall through */
+ case iro_End:
+ print_vcg_color(F, ird_color_blue);
+ break;
+ case iro_Block:
+ if (is_Block_dead(n))
+ print_vcg_color(F, ird_color_lightred);
+ else
+ print_vcg_color(F, ird_color_lightyellow);
+ break;
+ case iro_Phi:
+ print_vcg_color(F, ird_color_green);
+ break;
+ case iro_Mux:
+ case iro_Psi:
+ print_vcg_color(F, ird_color_gold);
+ break;
+ case iro_Pin:
+ print_vcg_color(F, ird_color_orchid);
+ break;
+ case iro_Const:
+ case iro_Proj:
+ case iro_Filter:
+ case iro_Tuple:
+ print_vcg_color(F, ird_color_yellow);
+ break;
+ case iro_ASM:
+ print_vcg_color(F, ird_color_darkyellow);
+ break;
+ default:
+ PRINT_DEFAULT_NODE_ATTR;
+ }
+}
+
+/* Adds a new node info dumper callback. */
+void *dump_add_node_info_callback(dump_node_info_cb_t *cb, void *data)
+{
+ hook_entry_t *info = xmalloc(sizeof(*info));
+
+ info->hook._hook_node_info = cb;
+ info->context = data;
+ register_hook(hook_node_info, info);
+
+ return info;
+}
+
+/* Remove a previously added info dumper callback. */
+void dump_remv_node_info_callback(void *handle)
+{
+ hook_entry_t *info = handle;
+ unregister_hook(hook_node_info, info);
+ xfree(info);
+}
+
+/**
+ * Dump the node information of a node n to a file F.
+ */
+static INLINE int dump_node_info(FILE *F, ir_node *n)
+{
+ int bad = 0;
+ const ir_op_ops *ops = get_op_ops(get_irn_op(n));
+
+ fprintf(F, " info1: \"");
+ bad = dump_irnode_to_file(F, n);
+ /* call the dump_node operation if available */
+ if (ops->dump_node)
+ bad = ops->dump_node(n, F, dump_node_info_txt);
+
+ /* allow additional info to be added */
+ hook_node_info(F, n);
+ fprintf(F, "\"\n");
+
+ return bad;
+}
+
+/**
+ * checks whether a node is "constant-like" ie can be treated "block-less"
+ */
+static INLINE
+int is_constlike_node(ir_node *n) {
+ ir_opcode code = get_irn_opcode(n);
+ return (code == iro_Const || code == iro_Bad || code == iro_NoMem || code == iro_SymConst || code == iro_Unknown);
+}
+
+
+/** 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) {
+ int i;
+ if (!get_opt_dump_const_local()) return;
+
+ /* Use visited flag to avoid outputting nodes twice.
+ initialize it first. */
+ for (i = 0; i < get_irn_arity(n); i++) {
+ ir_node *con = get_irn_n(n, i);
+ if (is_constlike_node(con)) {
+ set_irn_visited(con, get_irg_visited(current_ir_graph) - 1);
+ }
+ }
+
+ for (i = 0; i < get_irn_arity(n); i++) {
+ ir_node *con = get_irn_n(n, i);
+ if (is_constlike_node(con) && irn_not_visited(con)) {
+ int bad = 0;
+
+ mark_irn_visited(con);
+ /* Generate a new name for the node by appending the names of
+ n and const. */
+ fprintf(F, "node: {title: "); PRINT_CONSTID(n, con);
+ fprintf(F, " label: \"");
+ bad |= dump_node_label(F, con);
+ fprintf(F, "\" ");
+ bad |= dump_node_info(F, con);
+ dump_node_vcgattr(F, n, con, bad);
+ fprintf(F, "}\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) {
+ ir_node *blk;
+
+ if (!get_opt_dump_const_local()) return;
+
+ blk = get_nodes_block(n);
+ if (is_constlike_node(blk)) {
+ int bad = 0;
+
+ /* Generate a new name for the node by appending the names of
+ n and blk. */
+ fprintf(F, "node: {title: \""); PRINT_CONSTBLKID(n, blk);
+ fprintf(F, "\" label: \"");
+ bad |= dump_node_label(F, blk);
+ fprintf(F, "\" ");
+ bad |= dump_node_info(F, blk);
+ dump_node_vcgattr(F, n, blk, bad);
+ fprintf(F, "}\n");
+
+ fprintf(F, "edge: { sourcename: \"");
+ PRINT_NODEID(n);
+ fprintf(F, "\" targetname: \""); PRINT_CONSTBLKID(n,blk);
+
+ if (dump_edge_vcgattr_hook) {
+ fprintf(F, "\" ");
+ if (dump_edge_vcgattr_hook(F, n, -1)) {
+ fprintf(F, "}\n");
+ return;
+ } else {
+ fprintf(F, " " BLOCK_EDGE_ATTR "}\n");
+ return;
+ }
+ }
+
+ fprintf(F, "\" " BLOCK_EDGE_ATTR "}\n");
+ }
+}
+
+/**
+ * prints the error message of a node to a file F as info2.
+ */
+static void print_node_error(FILE *F, const char *err_msg)
+{
+ if (! err_msg)
+ return;
+
+ fprintf(F, " info2: \"%s\"", err_msg);
+}
+
+/**
+ * prints debug messages of a node to file F as info3.
+ */
+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);
+ }
+}
+
+/**
+ * Dump a node
+ */
+static void dump_node(FILE *F, ir_node *n)
+{
+ int bad = 0;
+ const char *p;
+
+ if (get_opt_dump_const_local() && is_constlike_node(n))
+ return;
+
+ /* dump this node */
+ fprintf(F, "node: {title: \""); PRINT_NODEID(n); fprintf(F, "\" label: \"");
+
+ bad = ! irn_vrfy_irg_dump(n, current_ir_graph, &p);
+ bad |= dump_node_label(F, n);
+ dump_node_ana_vals(F, n);
+ //dump_node_ana_info(F, n);
+ fprintf(F, "\" ");
+ bad |= dump_node_info(F, n);
+ print_node_error(F, p);
+ print_dbg_info(F, get_irn_dbg_info(n));
+ dump_node_vcgattr(F, n, NULL, bad);
+ fprintf(F, "}\n");
+ dump_const_node_local(F, n);
+
+ if(dump_node_edge_hook)
+ dump_node_edge_hook(F, n);
+#if DO_HEAPANALYSIS
+ dump_irn_chi_term(F, n);
+ dump_irn_state(F, n);
+#endif
+}
+
+/** dump the edge to the block this node belongs to */
+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);
+
+ if (get_opt_dump_const_local() && is_constlike_node(block)) {
+ dump_const_block_local(F, n);
+ } else {
+ fprintf(F, "edge: { sourcename: \"");
+ PRINT_NODEID(n);
+ fprintf(F, "\" targetname: ");
+ fprintf(F, "\""); PRINT_NODEID(block); fprintf(F, "\"");
+
+ if (dump_edge_vcgattr_hook) {
+ fprintf(F, " ");
+ if (dump_edge_vcgattr_hook(F, n, -1)) {
+ fprintf(F, "}\n");
+ return;
+ } else {
+ fprintf(F, " " BLOCK_EDGE_ATTR "}\n");
+ return;
+ }
+ }
+
+ fprintf(F, " " BLOCK_EDGE_ATTR "}\n");
+ }
+ }
+}
+
+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.
+ */
+ if (get_irn_n(from, -1) == get_irn_n(get_irn_n(from, to), -1))
+ fprintf(F, INTRA_DATA_EDGE_ATTR);
+ else
+ fprintf(F, INTER_DATA_EDGE_ATTR);
+}
+
+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.
+ */
+ if (get_irn_n(from, -1) == get_irn_n(get_irn_n(from, to), -1))
+ fprintf(F, INTRA_MEM_EDGE_ATTR);
+ else
+ fprintf(F, INTER_MEM_EDGE_ATTR);
+}
+
+/** 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) {
+ assert(from);
+
+ if (dump_edge_vcgattr_hook)
+ if (dump_edge_vcgattr_hook(F, from, to))
+ return;
+
+ if (dump_backedge_information_flag && is_backedge(from, to))
+ fprintf(F, BACK_EDGE_ATTR);
+
+ switch (get_irn_opcode(from)) {
+ case iro_Block:
+ fprintf(F, CF_EDGE_ATTR);
+ break;
+ case iro_Start: break;
+ case iro_End:
+ if (to >= 0) {
+ if (get_irn_mode(get_End_keepalive(from, to)) == mode_BB)
+ fprintf(F, KEEP_ALIVE_CF_EDGE_ATTR);
+ else
+ fprintf(F, KEEP_ALIVE_DF_EDGE_ATTR);
+ }
+ break;
+ default:
+ if (is_Proj(from)) {
+ if (get_irn_mode(from) == mode_M)
+ print_mem_edge_vcgattr(F, from, to);
+ else if (get_irn_mode(from) == mode_X)
+ fprintf(F, CF_EDGE_ATTR);
+ else
+ print_data_edge_vcgattr(F, from, to);
+ }
+ else if (get_irn_mode(get_irn_n(from, to)) == mode_M)
+ print_mem_edge_vcgattr(F, from, to);
+ else if (get_irn_mode(get_irn_n(from, to)) == mode_X)
+ fprintf(F, CF_EDGE_ATTR);
+ else
+ print_data_edge_vcgattr(F, from, to);
+ }
+}
+
+/** dump edges to our inputs */
+static void dump_ir_data_edges(FILE *F, ir_node *n) {
+ int i;
+ unsigned long visited = get_irn_visited(n);
+
+ if ((get_irn_op(n) == op_End) && (!dump_keepalive))
+ return;
+
+ /* dump the dependency edges. */
+ for (i = 0; i < get_irn_deps(n); ++i) {
+ ir_node *dep = get_irn_dep(n, i);
+
+ if(dep) {
+ fprintf(F, "edge: {sourcename: \"");
+ PRINT_NODEID(n);
+ fprintf(F, "\" targetname: ");
+ if ((get_opt_dump_const_local()) && is_constlike_node(dep)) {
+ PRINT_CONSTID(n, dep);
+ } else {
+ fprintf(F, "\"");
+ PRINT_NODEID(dep);
+ fprintf(F, "\"");
+ }
+ fprintf(F, " label: \"%d\" ", i);
+ fprintf(F, " color: darkgreen}\n");
+ }
+ }
+
+ for (i = 0; i < get_irn_arity(n); i++) {
+ ir_node * pred = get_irn_n(n, i);
+ assert(pred);
+
+ if ((get_interprocedural_view() && get_irn_visited(pred) < visited))
+ continue; /* pred not dumped */
+
+ if (dump_backedge_information_flag && is_backedge(n, i))
+ fprintf(F, "backedge: {sourcename: \"");
+ else
+ fprintf(F, "edge: {sourcename: \"");
+ PRINT_NODEID(n);
+ fprintf(F, "\" targetname: ");
+ if ((get_opt_dump_const_local()) && is_constlike_node(pred)) {
+ PRINT_CONSTID(n, pred);
+ } else {
+ fprintf(F, "\""); PRINT_NODEID(pred); fprintf(F, "\"");
+ }
+ fprintf(F, " label: \"%d\" ", i);
+ print_edge_vcgattr(F, n, i);
+ fprintf(F, "}\n");
+ }
+}
+
+/** Dumps a node and its edges but not the block edge
+ */
+static INLINE 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) {
+ FILE *F = env;
+ dump_node_wo_blockedge(n, env);
+ if (!node_floats(n)) dump_ir_block_edge(F, n);
+}