* Modified by: Goetz Lindenmaier, Hubert Schmidt
* Created:
* CVS-ID: $Id$
- * Copyright: (c) 1998-2003 Universität Karlsruhe
+ * Copyright: (c) 1998-2003 Universit�t Karlsruhe
* Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
*/
#ifdef HAVE_CONFIG_H
#include "firm_common_t.h"
-#include "irnode_t.h"
-#include "irgraph_t.h"
+#include "list.h"
+
+#include "irnode.h"
+#include "irgraph.h"
#include "irprog_t.h"
#include "entity_t.h"
-#include "irop_t.h"
+#include "irop.h"
#include "irdump_t.h"
#include "type_or_entity.h"
#include "irouts.h"
#include "irdom.h"
-#include "irloop.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 "panic.h"
+#include "error.h"
#include "array.h"
#include "pmap.h"
#include "eset.h"
#include "pset.h"
#if DO_HEAPANALYSIS
-void dump_irn_chi_term(FILE *FL, ir_node *n);
-void dump_irn_state(FILE *FL, ir_node *n);
-int get_opt_dump_abstvals(void);
+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;
-SeqNo get_Block_seqno(ir_node *n);
+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;
+/** 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;
+
+/** An additional edge hook. */
+static DUMP_NODE_EDGE_FUNC dump_node_edge_hook = NULL;
+
+void set_dump_node_edge_hook(DUMP_NODE_EDGE_FUNC func)
+{
+ dump_node_edge_hook = func;
+}
+
+DUMP_NODE_EDGE_FUNC get_dump_node_edge_hook(void)
+{
+ return dump_node_edge_hook;
+}
+
+
+static DUMP_NODE_EDGE_FUNC dump_block_edge_hook = NULL;
+
+void set_dump_block_edge_hook(DUMP_NODE_EDGE_FUNC func)
+{
+ dump_block_edge_hook = func;
+}
+
+DUMP_NODE_EDGE_FUNC get_dump_block_edge_hook(void)
+{
+ return dump_node_edge_hook;
+}
+
+
+/** 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;
+
+/* 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;
+}
+
+int get_opt_dump_const_local(void) {
+ if (!dump_out_edge_flag && !dump_loop_information_flag)
+ return dump_const_local;
+ else
+ return 0;
+}
+
+void only_dump_method_with_name(ident *name) {
+ dump_file_filter_id = 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_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
* 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(type *tp, int *bad)
+const char *get_type_name_ex(ir_type *tp, int *bad)
{
if (is_type(tp))
return get_type_name(tp);
return ERROR_TXT;
}
+/**
+ * printf the VCG color
+ */
+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, type *S, type *T, const char *fmt, ...)
+static void print_type_type_edge(FILE *F, ir_type *S, ir_type *T, const char *fmt, ...)
{
va_list 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, type *T, entity *E, const char *fmt, ...)
+static void print_type_ent_edge(FILE *F, ir_type *T, entity *E, const char *fmt, ...)
{
va_list 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, entity *E, type *T, const char *fmt, ...)
+static void print_ent_type_edge(FILE *F, entity *E, ir_type *T, const char *fmt, ...)
{
va_list 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, type *T, const char *fmt, ...)
+static void print_node_type_edge(FILE *F, const ir_node *N, ir_type *T, const char *fmt, ...)
{
va_list 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, type *E, int item, const char *fmt, ...)
+static void print_enum_item_edge(FILE *F, ir_type *E, int item, const char *fmt, ...)
{
va_list ap;
*/
static pmap *irdump_link_map = NULL;
-/** Creates the link attribut map. */
+/** 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.
*/
* Sets the private link field.
*/
static void ird_set_irn_link(ir_node *n, void *x) {
- if (!irdump_link_map) init_irdump();
+ if (!irdump_link_map)
+ init_irdump();
pmap_insert(irdump_link_map, (void *)n, x);
}
}
/**
- * Walker, clears tzhe private link field
+ * Walker, clears the private link field.
*/
static void clear_link(ir_node * node, void * env) {
ird_set_irn_link(node, NULL);
}
/**
- * If the entity has a ld_name, returns it, else returns the name of the entity.
+ * If the entity has a ld_name, returns it if the dump_ld_name is set,
+ * else returns the name of the entity.
*/
-const char *get_ent_dump_name(entity *ent) {
+static const char *_get_ent_dump_name(entity *ent, int dump_ld_name) {
if (!ent)
return "<NULL entity>";
- /* 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);
+ 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(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! */
- entity *ent = get_irg_entity(irg);
- return get_ent_dump_name(ent);
+ return _get_ent_dump_name(get_irg_entity(irg), 1);
}
/**
(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) {
+ irg_walk_graph(irg, pre, post, env);
+
+ if (dump_anchors) {
+ int i;
+
+ for (i = anchor_max - 1; i >= 0; --i) {
+ ir_node *n = irg->anchors[i];
+
+ if (n) {
+ /* reset the visit flag: will be increase in the walker */
+ set_irg_visited(irg, get_irg_visited(irg) - 1);
+ irg_walk(n, pre, post, env);
+ }
+ }
+ }
+}
+
/**
* Walker, allocates an array for all blocks and puts it's nodes non-floating nodes into this array.
*/
* 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, rem_view = get_interprocedural_view();
ir_graph *rem = current_ir_graph;
current_ir_graph = irg;
- for (i = 0; i < get_irp_n_irgs(); i++)
+ for (i = get_irp_n_irgs() - 1; i >= 0; --i)
ird_set_irg_link(get_irp_irg(i), NULL);
- irg_walk_graph(current_ir_graph, clear_link, collect_node, current_ir_graph);
+ 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(false);
+ 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);
return ird_get_irg_link(irg);
}
-/*******************************************************************/
-/* flags to steer output */
-/*******************************************************************/
-
-/** Dump only irgs with names start with this string */
-const char *dump_file_filter = "";
-
-/** A compiler option to turn off edge labels */
-static int edge_label = 1;
-/** A compiler option to turn off dumping values of constant entities */
-static int const_entities = 1;
-/** A compiler option to dump the keep alive edges */
-static int dump_keepalive = 0;
-/** Compiler options to dump analysis information in dump_ir_graph */
-int dump_out_edge_flag = 0;
-int dump_dominator_information_flag = 0;
-int dump_loop_information_flag = 0;
-int dump_backedge_information_flag = 1;
-int dump_const_local = 0;
-bool opt_dump_analysed_type_info = 1;
-bool opt_dump_pointer_values_to_info = 0; /* default off: for test compares!! */
-
-static const char *overrule_nodecolor = NULL;
-
-/** The vcg attribute hook. */
-static DUMP_NODE_VCGATTR_FUNC dump_node_vcgattr_hook = NULL;
-
-/* set the hook */
-void set_dump_node_vcgattr_hook(DUMP_NODE_VCGATTR_FUNC hook)
-{
- dump_node_vcgattr_hook = hook;
-}
-
-INLINE bool get_opt_dump_const_local(void) {
- if (!dump_out_edge_flag && !dump_loop_information_flag)
- return dump_const_local;
- else
- return false;
-}
-
-void only_dump_method_with_name(ident *name) {
- dump_file_filter = get_id_str(name);
-}
+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));
-/* To turn off display of edge labels. Edge labels offen cause xvcg to
- abort with a segmentation fault. */
-void turn_off_edge_labels(void) {
- edge_label = 0;
-}
-
-void dump_consts_local(bool b) {
- dump_const_local = b;
-}
-
-void dump_constant_entity_values(bool b) {
- const_entities = b;
-}
-
-void dump_keepalive_edges(bool b) {
- dump_keepalive = b;
-}
-
-bool get_opt_dump_keepalive_edges(void) {
- return dump_keepalive;
-}
-
-void dump_out_edges(bool b) {
- dump_out_edge_flag = b;
-}
+ current_ir_graph = irg;
-void dump_dominator_information(bool b) {
- dump_dominator_information_flag = b;
-}
+ lists->blk_list = NEW_ARR_F(ir_node *, 0);
+ lists->extbb_list = NEW_ARR_F(ir_extblk *, 0);
-void dump_loop_information(bool b) {
- dump_loop_information_flag = b;
-}
+ inc_irg_block_visited(irg);
+ for (i = ARR_LEN(blk_list) - 1; i >= 0; --i) {
+ ir_extblk *ext;
-void dump_backedge_information(bool b) {
- dump_backedge_information_flag = b;
-}
+ if (is_Block(blk_list[i])) {
+ ext = get_Block_extbb(blk_list[i]);
-/* 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 dump_analysed_type_info(bool b) {
- opt_dump_analysed_type_info = b;
-}
+ 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);
-void dump_pointer_values_to_info(bool b) {
- opt_dump_pointer_values_to_info = b;
+ current_ir_graph = rem;
+ ird_set_irg_link(irg, lists);
+ return lists;
}
/*-----------------------------------------------------------------*/
/*
* dump the name of a node n to the File F.
*/
-int
-dump_node_opcode(FILE *F, ir_node *n)
+int dump_node_opcode(FILE *F, ir_node *n)
{
int bad = 0;
+ const ir_op_ops *ops = get_op_ops(get_irn_op(n));
- switch(get_irn_opcode(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;
&& get_Proj_proj(n) == get_Cond_defaultProj(pred)
&& get_irn_mode(get_Cond_selector(pred)) != mode_b)
fprintf (F, "defProj");
-/*
- * else if (get_irn_opcode(pred) == iro_Proj && get_irn_opcode(get_Proj_pred(pred)) == iro_Start)
- * fprintf (F, "Arg");
- */
else
goto default_case;
} break;
case iro_Load:
fprintf (F, "%s[%s]", get_irn_opname(n), get_mode_name_ex(get_Load_mode(n), &bad));
break;
+ case iro_Block:
+ fprintf (F, "%s%s", is_Block_dead(n) ? "Dead " : "", get_irn_opname(n));
+ break;
+ default:
default_case:
- default: {
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 INLINE int
-dump_node_mode(FILE *F, ir_node *n)
+static int dump_node_mode(FILE *F, ir_node *n)
{
int bad = 0;
- opcode iro = get_irn_opcode(n);
+ const ir_op_ops *ops = get_op_ops(get_irn_op(n));
+ 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:
}
/**
- * Dump the tpe of a node n to a file F if it's known.
+ * 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) == irg_typeinfo_consistent ||
- get_irg_typeinfo_state(current_ir_graph) == irg_typeinfo_inconsistent) {
- type *tp = get_irn_typeinfo_type(n);
+ 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));
+ fprintf(F, "[%s] ", get_type_name_ex(tp, &bad));
else
- fprintf(F, " []");
+ 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 {
+ 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(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(T_result),
+ X(P_value_res_base),
+ X(X_except),
+ X(M_except)
+#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_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_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_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_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_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_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_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_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_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_except),
+ X(res),
+ X(M_except)
+#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 addinional node attributes of some nodes to a file F.
+ * Dump additional node attributes of some nodes to a file F.
*/
-static INLINE int
+static int
dump_node_nodeattr(FILE *F, ir_node *n)
{
int bad = 0;
+ ir_node *pred;
+ 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 (false && get_interprocedural_view()) {
- fprintf (F, "%s", get_ent_dump_name(get_irg_entity(current_ir_graph)));
+ if (0 && get_interprocedural_view()) {
+ fprintf (F, "%s ", get_ent_dump_name(get_irg_entity(current_ir_graph)));
}
break;
+
case iro_Proj:
- if (get_irn_opcode(get_Proj_pred(n)) == iro_Cmp) {
- fprintf (F, "%s", get_pnc_string(get_Proj_proj(n)));
- } else {
- fprintf (F, "%ld", get_Proj_proj(n));
+ 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:
- fprintf (F, "%ld", get_Filter_proj(n));
+ 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)));
+ 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));
+ 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)));
+ 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:
return bad;
}
+#include <math.h>
+#include "execution_frequency.h"
+#include "callgraph.h"
+
+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);
+ fprintf(F, "%ld", get_irn_node_nr(n));
+
+ return bad;
+}
+
+
/**
- * dumps the attributes of a node n into the file F.
+ * 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) {
- fprintf(F, "color: red");
+ print_vcg_color(F, ird_color_red);
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:
case iro_EndExcept:
/* fall through */
case iro_End:
- fprintf (F, "color: blue");
+ print_vcg_color(F, ird_color_blue);
break;
case iro_Block:
if (is_Block_dead(n))
- fprintf (F, "color: lightred");
+ print_vcg_color(F, ird_color_lightred);
else
- fprintf (F, "color: lightyellow");
+ print_vcg_color(F, ird_color_lightyellow);
break;
case iro_Phi:
- fprintf (F, "color: green");
+ print_vcg_color(F, ird_color_green);
+ break;
+ case iro_Mux:
+ case iro_Psi:
+ print_vcg_color(F, ird_color_gold);
break;
case iro_Const:
case iro_Proj:
case iro_Filter:
case iro_Tuple:
- fprintf (F, "color: yellow");
+ print_vcg_color(F, ird_color_yellow);
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));
- if (overrule_nodecolor) fprintf(F, " color: %s", overrule_nodecolor);
+ 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;
+{
+ 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 wheater a node is "constant-like", ie can be treated "block-less"
+ * checks whether a node is "constant-like" ie can be treated "block-less"
*/
static INLINE
-bool is_constlike_node(ir_node *n) {
+int is_constlike_node(ir_node *n) {
ir_op *op = get_irn_op(n);
return (op == op_Const || op == op_Bad || op == op_NoMem || op == op_SymConst || op == op_Unknown);
}
n and const. */
fprintf(F, "node: {title: "); PRINT_CONSTID(n, con);
fprintf(F, " label: \"");
- bad |= dump_node_opcode(F, con);
- bad |= dump_node_mode(F, con);
- bad |= dump_node_typeinfo(F, con);
- fprintf (F, " ");
- bad |= dump_node_nodeattr(F, con);
- fprintf(F, " %ld", get_irn_node_nr(con));
+ bad |= dump_node_label(F, con);
fprintf(F, "\" ");
bad |= dump_node_info(F, con);
dump_node_vcgattr(F, n, con, bad);
n and blk. */
fprintf(F, "node: {title: \""); PRINT_CONSTBLKID(n, blk);
fprintf(F, "\" label: \"");
- bad |= dump_node_opcode(F, blk);
- bad |= dump_node_mode(F, blk);
- bad |= dump_node_typeinfo(F, blk);
- fprintf (F, " ");
- bad |= dump_node_nodeattr(F, blk);
- fprintf(F, " %ld", get_irn_node_nr(blk));
+ bad |= dump_node_label(F, blk);
fprintf(F, "\" ");
bad |= dump_node_info(F, blk);
dump_node_vcgattr(F, n, blk, bad);
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");
}
}
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
*/
fprintf(F, "node: {title: \""); PRINT_NODEID(n); fprintf(F, "\" label: \"");
bad = ! irn_vrfy_irg_dump(n, current_ir_graph, &p);
- bad |= dump_node_opcode(F, n);
- bad |= dump_node_mode(F, n);
- bad |= dump_node_typeinfo(F, n);
- fprintf(F, " ");
- bad |= dump_node_nodeattr(F, n);
- fprintf(F, " %ld", get_irn_node_nr(n));
+ 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);
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) {
- if (get_nodes_block(from) == get_nodes_block(get_irn_n(from, 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) {
- if (get_nodes_block(from) == get_nodes_block(get_irn_n(from, 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_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);
case iro_Block:
fprintf (F, CF_EDGE_ATTR);
break;
- case iro_Start: break;
+ case iro_Start: break;
case iro_End:
if (to >= 0) {
if (get_irn_mode(get_End_keepalive(from, to)) == mode_BB)
fprintf (F, INTER_MEM_EDGE_ATTR);
}
break;
- case iro_EndReg:
- case iro_EndExcept:
- case iro_Jmp:
- case iro_Break:
- case iro_Cond:
- print_data_edge_vcgattr(F, from, to);
- break;
- case iro_Return:
- case iro_Raise:
- if (to == 0)
- print_mem_edge_vcgattr(F, from, to);
- else
- print_data_edge_vcgattr(F, from, to);
- break;
- case iro_Const:
- case iro_SymConst:
- print_data_edge_vcgattr(F, from, to);
- break;
- case iro_Sel:
- case iro_Call:
- if (to == 0)
- print_mem_edge_vcgattr(F, from, to);
- else
- print_data_edge_vcgattr(F, from, to);
- break;
- case iro_CallBegin:
- case iro_Add:
- case iro_Sub:
- case iro_Minus:
- case iro_Mul:
- print_data_edge_vcgattr(F, from, to);
- break;
- case iro_Quot:
- case iro_DivMod:
- case iro_Div:
- case iro_Mod:
- if (to == 0)
- print_mem_edge_vcgattr(F, from, to);
- else
- print_data_edge_vcgattr(F, from, to);
- break;
- case iro_Abs:
- case iro_And:
- case iro_Or:
- case iro_Eor:
- case iro_Shl:
- case iro_Shr:
- case iro_Shrs:
- case iro_Rot:
- case iro_Cmp:
- case iro_Conv:
- print_data_edge_vcgattr(F, from, to);
- break;
- case iro_Phi:
- if (get_irn_modecode(from) == irm_M)
- fprintf (F, INTER_MEM_EDGE_ATTR);
- else
- print_data_edge_vcgattr(F, from, to);
- break;
- case iro_Load:
- case iro_Store:
- case iro_Alloc:
- case iro_Free:
- if (to == 0)
- print_mem_edge_vcgattr(F, from, to);
- else
- print_data_edge_vcgattr(F, from, to);
- break;
- case iro_Sync:
- print_mem_edge_vcgattr(F, from, to);
- break;
- case iro_Tuple: break;
- case iro_Proj:
- case iro_Filter:
- switch (get_irn_modecode(from)) {
- case irm_X:
- fprintf (F, CF_EDGE_ATTR);
- break;
- case irm_M:
- fprintf (F, INTER_MEM_EDGE_ATTR);
- break;
- default:
- print_data_edge_vcgattr(F, from, to);
- 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);
}
- break;
- case iro_Bad: break;
- case iro_Unknown: break;
- case iro_Id:
- switch (get_irn_modecode(from)) {
- case irm_M:
- fprintf (F, INTRA_MEM_EDGE_ATTR);
- break;
- case irm_X:
+ 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);
- break;
- default:
+ else
print_data_edge_vcgattr(F, from, to);
- break;
- } break;
- default:
- ;
}
}
current_ir_graph = get_const_code_irg();
irg_walk(value, dump_const_node, NULL, F);
/* Decrease visited flag so that we walk with the same flag for the next
- expresssion. This guarantees that we don't dump the same node twice,
+ expression. This guarantees that we don't dump the same node twice,
as for const expressions cse is performed to save memory. */
set_irg_visited(current_ir_graph, get_irg_visited(current_ir_graph) -1);
current_ir_graph = rem;
static void
dump_whole_block(FILE *F, ir_node *block) {
ir_node *node;
+ dumper_colors color = ird_color_yellow;
+
assert(is_Block(block));
fprintf(F, "graph: { title: \"");
PRINT_NODEID(block);
fprintf(F, "\" label: \"");
- dump_node_opcode(F, block);
- fprintf (F, " %ld", get_irn_node_nr(block));
+ dump_node_label(F, block);
#if DO_HEAPANALYSIS
if (get_opt_dump_abstvals())
fprintf (F, " seqno: %d", (int)get_Block_seqno(block));
#endif
- fprintf(F, "\" status:clustered color:%s \n",
- get_Block_matured(block) ? "yellow" : "red");
+
+ /* colorize blocks */
+ if (! get_Block_matured(block))
+ color = ird_color_red;
+ if (is_Block_dead(block))
+ color = ird_color_orange;
+
+ fprintf(F, "\" status:clustered ");
+ print_vcg_color(F, color);
+ fprintf(F, "\n");
+
+ /* yComp can show attributes for blocks, XVCG parses but ignores them */
+ dump_node_info(F, block);
+ print_dbg_info(F, get_irn_dbg_info(block));
/* dump the blocks edges */
dump_ir_data_edges(F, block);
+ if (dump_block_edge_hook)
+ dump_block_edge_hook(F, block);
+
/* dump the nodes that go into the block */
for (node = ird_get_irn_link(block); node; node = ird_get_irn_link(node)) {
dump_node(F, node);
} else {
/* Nodes that are not in a Block. */
dump_node(F, node);
- if (is_Bad(get_nodes_block(node)) && !node_floats(node)) {
+ if (!node_floats(node) && is_Bad(get_nodes_block(node))) {
dump_const_block_local(F, node);
}
dump_ir_data_edges(F, node);
current_ir_graph = rem;
}
-/** Dumps an irg as a graph.
+/**
+ * Dump the info for an irg.
+ * Parsed by XVCG but not shown. use yComp.
+ */
+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");
+}
+
+/** 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) {
+ entity *ent = get_irg_entity(irg);
fprintf(F, "graph: { title: \"");
PRINT_IRGID(irg);
fprintf(F, "\" label: \"%s\" status:clustered color:white \n",
- get_ent_dump_name(get_irg_entity(irg)));
+ get_ent_dump_name(ent));
+
+ dump_graph_info(F, irg);
+ print_dbg_info(F, get_entity_dbg_info(ent));
dump_block_graph(F, irg);
fprintf(F, "}\n\n");
}
+/** 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) {
+ int i;
+ ir_graph *rem = current_ir_graph;
+ ir_extblk **arr = ird_get_irg_link(irg);
+ current_ir_graph = irg;
+
+ for (i = ARR_LEN(arr) - 1; i >= 0; --i) {
+ ir_extblk *extbb = arr[i];
+ ir_node *leader = get_extbb_leader(extbb);
+ int j;
+
+ fprintf(F, "graph: { title: \"");
+ PRINT_EXTBBID(leader);
+ fprintf(F, "\" label: \"ExtBB %ld\" status:clustered color:lightgreen\n",
+ get_irn_node_nr(leader));
+
+ for (j = ARR_LEN(extbb->blks) - 1; j >= 0; --j) {
+ ir_node * node = extbb->blks[j];
+ if (is_Block(node)) {
+ /* Dumps the block and all the nodes in the block, which are to
+ be found in Block->link. */
+ dump_whole_block(F, node);
+ } else {
+ /* Nodes that are not in a Block. */
+ dump_node(F, node);
+ if (is_Bad(get_nodes_block(node)) && !node_floats(node)) {
+ dump_const_block_local(F, node);
+ }
+ dump_ir_data_edges(F, node);
+ }
+ }
+ fprintf(F, "}\n");
+ }
+
+ if (dump_loop_information_flag && (get_irg_loopinfo_state(irg) & loopinfo_valid))
+ dump_loop_nodes_into_graph(F, irg);
+
+ current_ir_graph = rem;
+ free_extbb(irg);
+}
+
+
/*******************************************************************/
/* Basic type and entity nodes and edges. */
/*******************************************************************/
}
}
-
-static int print_type_info(FILE *F, type *tp) {
+#if 0
+static int print_type_info(FILE *F, ir_type *tp) {
int bad = 0;
if (get_type_state(tp) == layout_undefined) {
return bad;
}
-static void print_typespecific_info(FILE *F, type *tp) {
+static void print_typespecific_info(FILE *F, ir_type *tp) {
switch (get_type_tpop_code(tp)) {
case tpo_class:
{
default: break;
} /* switch type */
}
+#endif
-
-static void print_typespecific_vcgattr(FILE *F, type *tp) {
+static void print_typespecific_vcgattr(FILE *F, ir_type *tp) {
switch (get_type_tpop_code(tp)) {
case tpo_class:
{
} /* switch type */
}
-static int print_type_node(FILE *F, type *tp)
+
+int dump_type_node(FILE *F, ir_type *tp)
{
int bad = 0;
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);
- fprintf (F, "\"");
+#else
+ dump_type_to_file(F, tp, dump_verbosity_max);
+#endif
+ fprintf (F, "\"\n");
+ print_dbg_info(F, get_type_dbg_info(tp));
print_typespecific_vcgattr(F, tp);
fprintf (F, "}\n");
return bad;
}
+
#define X(a) case a: fprintf(F, #a); break
void dump_entity_node(FILE *F, entity *ent, int color)
{
fprintf (F, "label: ");
fprintf (F, "\"ent %s\" ", get_ent_dump_name(ent));
if (color)
- fprintf(F, "color: %d", color);
+ fprintf(F, "color:%d", color);
else
fprintf (F, ENTITY_NODE_ATTR);
fprintf (F, "\n info1: \"");
dump_entity_to_file(F, ent, dump_verbosity_entattrs | dump_verbosity_entconsts);
- fprintf(F, "\"\n}\n");
+ fprintf(F, "\"\n");
+ print_dbg_info(F, get_entity_dbg_info(ent));
+ fprintf(F, "}\n");
}
#undef X
-static void dump_enum_item(FILE *F, type *tp, int pos)
+static void dump_enum_item(FILE *F, ir_type *tp, int pos)
{
char buf[1024];
ident *id = get_enumeration_nameid(tp, pos);
} break;
case k_type:
{
- type *tp = (type *)tore;
- print_type_node(F, tp);
+ ir_type *tp = (ir_type *)tore;
+ dump_type_node(F, tp);
/* and now the edges */
switch (get_type_tpop_code(tp)) {
case tpo_class:
} break; /* case k_entity */
case k_type:
{
- type *tp = (type *)tore;
+ ir_type *tp = (ir_type *)tore;
if (tp == get_glob_type()) break;
switch (get_type_tpop_code(tp)) {
case tpo_class: {
- print_type_node(F, tp);
+ dump_type_node(F, tp);
/* and now the edges */
for (i=0; i < get_class_n_supertypes(tp); i++)
{
fprintf (F, " info1: \"");
fprintf (F, " loop nr: %d", get_loop_loop_nr(loop));
#if DEBUG_libfirm /* GL @@@ debug analyses */
- fprintf (F, "\n The loop was analyzed %d times.", (int)get_loop_link(loop));
+ fprintf (F, "\n The loop was analyzed %d times.", PTR_TO_INT(get_loop_link(loop)));
#endif
fprintf (F, "\"");
}
/**
* dumps the VCG header
*/
-INLINE void dump_vcg_header(FILE *F, const char *name, const char *orientation) {
+void dump_vcg_header(FILE *F, const char *name, const char *orientation) {
char *label;
if (edge_label) {
"port_sharing: no\n"
"orientation: %s\n"
"classname 1: \"intrablock Data\"\n"
- "classname 16: \"interblock Data\"\n"
"classname 2: \"Block\"\n"
- "classname 13: \"Control Flow\"\n"
- "classname 18: \"Exception Control Flow for Interval Analysis\"\n"
- "classname 14: \"intrablock Memory\"\n"
- "classname 17: \"interblock Memory\"\n"
- "classname 15: \"Dominators\"\n"
"classname 3: \"Entity type\"\n"
"classname 4: \"Entity owner\"\n"
"classname 5: \"Method Param\"\n"
"classname 10: \"Array Element Type\"\n"
"classname 11: \"Overwrites\"\n"
"classname 12: \"Member\"\n"
+ "classname 13: \"Control Flow\"\n"
+ "classname 14: \"intrablock Memory\"\n"
+ "classname 15: \"Dominators\"\n"
+ "classname 16: \"interblock Data\"\n"
+ "classname 17: \"interblock Memory\"\n"
+ "classname 18: \"Exception Control Flow for Interval Analysis\"\n"
+ "classname 19: \"Postdominators\"\n"
"infoname 1: \"Attribute\"\n"
- "infoname 2: \"Verification errors\"\n",
+ "infoname 2: \"Verification errors\"\n"
+ "infoname 3: \"Debug info\"\n",
name, label, orientation);
/* don't use all, the range is too whith/black. */
/* strncpy (fname, nm, len); */ /* copy the filename */
j = 0;
- for (i = 0; i < len; ++i) { /* replase '/' in the name: escape by @. */
+ for (i = 0; i < len; ++i) { /* replace '/' in the name: escape by @. */
if (nm[i] == '/') {
fname[j] = '@'; j++; fname[j] = '1'; j++;
} else if (nm[i] == '@') {
strcat (fname, suffix1); /* append file suffix */
strcat (fname, suffix2); /* append file suffix */
strcat (fname, ".vcg"); /* append the .vcg suffix */
- F = fopen (fname, "w"); /* open file for writing */
+
+ /* vcg really expect only a <CR> at end of line, so
+ * the "b"inary mode is what you mean (and even needed for Win32)
+ */
+ F = fopen (fname, "wb"); /* open file for writing */
if (!F) {
panic("cannot open %s for writing (%m)", fname); /* not reached */
}
/**
* open a vcg file
*
- * @param irg The graph to be dumped
+ * @param name prefix file name
* @param suffix filename suffix
*/
FILE *vcg_open_name (const char *name, const char *suffix) {
if (!suffix) suffix = "";
/** open file for vcg graph */
- fname = malloc (len * 2 + 5 + strlen(suffix));
+ fname = xmalloc(len * 2 + 5 + strlen(suffix));
/* strcpy (fname, name);*/ /* copy the filename */
j = 0;
- for (i = 0; i < len; ++i) { /* replase '/' in the name: escape by @. */
+ for (i = 0; i < len; ++i) { /* replace '/' in the name: escape by @. */
if (name[i] == '/') {
fname[j] = '@'; j++; fname[j] = '1'; j++;
} else if (name[i] == '@') {
fname[j] = '\0';
strcat (fname, suffix);
strcat (fname, ".vcg"); /* append the .vcg suffix */
- F = fopen (fname, "w"); /* open file for writing */
+
+ /* vcg really expect only a <CR> at end of line, so
+ * the "b"inary mode is what you mean (and even needed for Win32)
+ */
+ F = fopen (fname, "wb"); /* open file for writing */
if (!F) {
panic ("cannot open %s for writing (%m)", fname); /* not reached */
}
/************************************************************************/
/************************************************************************/
-/* Dump ir graphs, differnt formats and additional information. */
+/* Dump ir graphs, different formats and additional information. */
/************************************************************************/
/** Routine to dump a graph, blocks as conventional nodes. */
char *suffix1;
rem = current_ir_graph;
- if (strncmp(get_entity_name(get_irg_entity(irg)),
- dump_file_filter, strlen(dump_file_filter)) != 0) return;
+ if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg)))) return;
current_ir_graph = irg;
if (get_interprocedural_view()) suffix1 = "-pure-ip";
f = vcg_open(irg, suffix, suffix1);
dump_vcg_header(f, get_irg_dump_name(irg), NULL);
+ /* call the dump graph hook */
+ if (dump_ir_graph_hook)
+ if (dump_ir_graph_hook(f, irg))
+ return;
+
/* walk over the graph */
/* dump_whole_node must be called in post visiting predecessors */
- irg_walk(get_irg_end(irg), NULL, dump_whole_node, f);
+ ird_walk_graph(irg, NULL, dump_whole_node, f);
/* dump the out edges in a separate walk */
if ((dump_out_edge_flag) && (get_irg_outs_state(irg) != outs_none)) {
current_ir_graph = rem;
}
-
-void
-dump_ir_block_graph (ir_graph *irg, const char *suffix)
+/* Dump a firm graph without explicit block nodes. */
+void dump_ir_block_graph (ir_graph *irg, const char *suffix)
{
FILE *f;
int i;
char *suffix1;
- if (strncmp(get_entity_name(get_irg_entity(irg)), dump_file_filter, strlen(dump_file_filter)) != 0)
+ if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
return;
if (get_interprocedural_view()) suffix1 = "-ip";
construct_block_lists(irg);
- for (i = 0; i < get_irp_n_irgs(); i++) {
+ /*
+ * If we are in the interprocedural view, we dump not
+ * only the requested irg but also all irgs that can be reached
+ * from irg.
+ */
+ for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
ir_node **arr = ird_get_irg_link(get_irp_irg(i));
if (arr) {
dump_graph_from_list(f, get_irp_irg(i));
vcg_close(f);
}
-/** dumps a graph with type information */
+/* Dump a firm graph without explicit block nodes but grouped in extended blocks. */
+void dump_ir_extblock_graph (ir_graph *irg, const char *suffix)
+{
+ FILE *F;
+ int i;
+ char *suffix1;
+ entity *ent;
+
+ if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
+ return;
+
+ if (get_irg_extblk_state(irg) != extblk_valid)
+ compute_extbb(irg);
+
+ if (get_interprocedural_view()) suffix1 = "-ip";
+ else suffix1 = "";
+
+ ent = get_irg_entity(irg);
+
+ F = vcg_open(irg, suffix, suffix1);
+ dump_vcg_header(F, get_irg_dump_name(irg), NULL);
+
+ construct_extblock_lists(irg);
+
+ fprintf(F, "graph: { title: \"");
+ PRINT_IRGID(irg);
+ fprintf(F, "\" label: \"%s\" status:clustered color: white \n",
+ get_ent_dump_name(ent));
+
+ dump_graph_info(F, irg);
+ print_dbg_info(F, get_entity_dbg_info(ent));
+
+ for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+ ir_graph *irg = get_irp_irg(i);
+ list_tuple *lists = ird_get_irg_link(irg);
+
+ if (lists) {
+ /* dump the extended blocks first */
+ if (ARR_LEN(lists->extbb_list)) {
+ ird_set_irg_link(irg, lists->extbb_list);
+ dump_extblock_graph(F, irg);
+ }
+
+ /* we may have blocks without extended blocks, bad for instance */
+ if (ARR_LEN(lists->blk_list)) {
+ ird_set_irg_link(irg, lists->blk_list);
+ dump_block_graph(F, irg);
+ }
+
+ DEL_ARR_F(lists->extbb_list);
+ DEL_ARR_F(lists->blk_list);
+ xfree(lists);
+ }
+ }
+
+ /* Close the vcg information for the irg */
+ fprintf(F, "}\n\n");
+
+ vcg_close(F);
+ free_extbb(irg);
+}
+
+/* dumps a graph with type information */
void
dump_ir_graph_w_types (ir_graph *irg, const char *suffix)
{
FILE *f;
ir_graph *rem = current_ir_graph;
char *suffix1;
+ int rem_dump_const_local;
/* if a filter is set, dump only the irg's that match the filter */
- if (strncmp(get_entity_name(get_irg_entity(irg)), dump_file_filter, strlen(dump_file_filter)) != 0)
+ if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
return;
current_ir_graph = irg;
+ rem_dump_const_local = dump_const_local;
+ /* dumping types does not work with local nodes */
+ dump_const_local = 0;
if (get_interprocedural_view()) suffix1 = "-pure-wtypes-ip";
else suffix1 = "-pure-wtypes";
irg_walk(get_irg_end(irg), dump_node2type_edges, NULL, f);
vcg_close(f);
+ dump_const_local = rem_dump_const_local;
current_ir_graph = rem;
}
int i;
char *suffix1;
ir_graph *rem = current_ir_graph;
+ int rem_dump_const_local;
/* if a filter is set, dump only the irg's that match the filter */
- if (strncmp(get_entity_name(get_irg_entity(irg)), dump_file_filter, strlen(dump_file_filter)) != 0)
+ if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
return;
+ rem_dump_const_local = dump_const_local;
+ /* dumping types does not work with local nodes */
+ dump_const_local = 0;
+
if (get_interprocedural_view()) suffix1 = "-wtypes-ip";
else suffix1 = "-wtypes";
f = vcg_open(irg, suffix, suffix1);
/* dump common blocked ir graph */
construct_block_lists(irg);
- for (i = 0; i < get_irp_n_irgs(); i++) {
+ for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
ir_node **arr = ird_get_irg_link(get_irp_irg(i));
if (arr) {
dump_graph_from_list(f, get_irp_irg(i));
/* dump edges from graph to type info */
irg_walk(get_irg_end(irg), dump_node2type_edges, NULL, f);
- current_ir_graph = rem;
vcg_close(f);
+ dump_const_local = rem_dump_const_local;
+ current_ir_graph = rem;
}
/*---------------------------------------------------------------------*/
static void
dump_block_to_cfg(ir_node *block, void *env) {
FILE *F = env;
- int i, fl;
+ int i, fl = 0;
ir_node *pred;
if (is_Block(block)) {
PRINT_NODEID(block);
fprintf (F, "\" ");
fprintf(F, "info1:\"");
- if (dump_dominator_information_flag)
- fprintf(F, "dom depth %d\n", get_Block_dom_depth(block));
-
- /* show arity and possible Bad predecessors of the block */
- fprintf(F, "arity: %d\n", get_Block_n_cfgpreds(block));
- for (fl = i = 0; i < get_Block_n_cfgpreds(block); ++i) {
- ir_node *pred = get_Block_cfgpred(block, i);
- if (is_Bad(pred)) {
- if (! fl)
- fprintf(F, "Bad pred at pos: ");
- fprintf(F, "%d ", i);
- fl = 1;
- }
- }
- if (fl)
- fprintf(F, "\n");
+
+ /* the generic version. */
+ dump_irnode_to_file(F, block);
+
+ /* Check whether we have bad predecessors to color the block. */
+ for (i = 0; i < get_Block_n_cfgpreds(block); ++i)
+ if ((fl = is_Bad(get_Block_cfgpred(block, i))))
+ break;
fprintf (F, "\""); /* closing quote of info */
fprintf (F, "\"}\n");
}
- /* Dump dominator edge */
- if (dump_dominator_information_flag && get_Block_idom(block)) {
- pred = get_Block_idom(block);
- fprintf (F, "edge: { sourcename: \"");
- PRINT_NODEID(block);
- fprintf (F, "\" targetname: \"");
- PRINT_NODEID(pred);
- fprintf (F, "\" " DOMINATOR_EDGE_ATTR "}\n");
+ /* Dump dominator/postdominator edge */
+ if (dump_dominator_information_flag) {
+ if (get_irg_dom_state(current_ir_graph) == dom_consistent && get_Block_idom(block)) {
+ pred = get_Block_idom(block);
+ fprintf (F, "edge: { sourcename: \"");
+ PRINT_NODEID(block);
+ fprintf (F, "\" targetname: \"");
+ PRINT_NODEID(pred);
+ fprintf (F, "\" " DOMINATOR_EDGE_ATTR "}\n");
+ }
+ if (get_irg_postdom_state(current_ir_graph) == dom_consistent && get_Block_ipostdom(block)) {
+ pred = get_Block_ipostdom(block);
+ fprintf (F, "edge: { sourcename: \"");
+ PRINT_NODEID(block);
+ fprintf (F, "\" targetname: \"");
+ PRINT_NODEID(pred);
+ fprintf (F, "\" " POSTDOMINATOR_EDGE_ATTR "}\n");
+ }
}
}
}
{
FILE *f;
ir_graph *rem = current_ir_graph;
- int ddif = dump_dominator_information_flag;
int ipv = get_interprocedural_view();
/* if a filter is set, dump only the irg's that match the filter */
- if (strncmp(get_entity_name(get_irg_entity(irg)), dump_file_filter, strlen(dump_file_filter)) != 0)
+ if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
return;
current_ir_graph = irg;
if (ipv) {
printf("Warning: dumping cfg not in interprocedural view!\n");
- set_interprocedural_view(false);
+ set_interprocedural_view(0);
}
- if (get_irg_dom_state(irg) != dom_consistent)
- dump_dominator_information_flag = 0;
-
/* walk over the blocks in the graph */
irg_block_walk(get_irg_end(irg), dump_block_to_cfg, NULL, f);
dump_node(f, get_irg_bad(irg));
- dump_dominator_information_flag = ddif;
set_interprocedural_view(ipv);
vcg_close(f);
current_ir_graph = rem;
void dump_callgraph(const char *suffix) {
FILE *F;
- int i, n_irgs = get_irp_n_irgs();
+ int i;
int rem = edge_label;
edge_label = 1;
//ident *prefix = new_id_from_str("java/");
F = vcg_open_name("Callgraph", suffix);
dump_vcg_header(F, "Callgraph", NULL);
- for (i = 0; i < n_irgs; ++i) {
+ for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
ir_graph *irg = get_irp_irg(i);
entity *ent = get_irg_entity(irg);
int j, n_callees = get_irg_n_callees(irg);
int be = is_irg_callee_backedge(irg, j);
char *attr;
attr = (be) ?
- "label:\"recursion %d\" color: %d" :
- "label:\"calls %d\" color: %d";
+ "label:\"recursion %d\" color:%d" :
+ "label:\"calls %d\" color:%d";
print_ent_ent_edge(F, ent, c, be, attr, get_irg_callee_loop_depth(irg, j), get_entity_color(ent));
}
}
FILE *f;
int i;
int rem_view = get_interprocedural_view();
- set_interprocedural_view(true);
+ set_interprocedural_view(1);
f = vcg_open_name("All_graphs", suffix);
dump_vcg_header(f, "All_graphs", NULL);
/* collect nodes in all irgs reachable in call graph*/
- for (i = 0; i < get_irp_n_irgs(); i++)
+ for (i = get_irp_n_irgs() - 1; i >= 0; --i)
ird_set_irg_link(get_irp_irg(i), NULL);
cg_walk(clear_link, collect_node, NULL);
/* dump all graphs */
- for (i = 0; i < get_irp_n_irgs(); i++) {
+ for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
current_ir_graph = get_irp_irg(i);
assert(ird_get_irg_link(current_ir_graph));
dump_graph_from_list(f, current_ir_graph);
rem = current_ir_graph;
/* if a filter is set, dump only the irg's that match the filter */
- if (strncmp(get_entity_name(get_irg_entity(irg)), dump_file_filter, strlen(dump_file_filter)) != 0) return;
+ if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg)))) return;
current_ir_graph = irg;
/* walk over the blocks in the graph */
type_walk_irg(irg, dump_type_info, NULL, f);
/* The walker for the const code can be called several times for the
- same (sub) experssion. So that no nodes are dumped several times
+ same (sub) expression. So that no nodes are dumped several times
we decrease the visited flag of the corresponding graph after each
walk. So now increase it finally. */
inc_irg_visited(get_const_code_irg());
}
void
-dump_class_hierarchy (bool entities, const char *suffix)
+dump_class_hierarchy (int entities, const char *suffix)
{
FILE *f = vcg_open_name("class_hierarchy", suffix);
h_env_t env;
- env.f = f;
+ env.f = f;
+ env.dump_ent = entities;
dump_vcg_header(f, "class_hierarchy", NULL);
- if (entities)
- env.dump_ent = 1;
- else
- env.dump_ent = 0;
type_walk(dump_class_hierarchy_node, NULL, &env);
vcg_close(f);
}
/*---------------------------------------------------------------------*/
void dump_all_ir_graphs(dump_graph_func *dmp_grph, const char *suffix) {
- int i, n_irgs = get_irp_n_irgs();
- for (i = 0; i < n_irgs; ++i) {
+ int i;
+ for (i = get_irp_n_irgs() - 1; i >= 0; --i)
dmp_grph(get_irp_irg(i), suffix);
- }
}
else
fprintf(F, "\n");
- bad |= dump_node_opcode(F, n);
- bad |= dump_node_mode(F, n);
- bad |= dump_node_typeinfo(F, n);
- fprintf (F, " ");
- bad |= dump_node_nodeattr(F, n);
- fprintf (F, " %ld", get_irn_node_nr(n));
+ bad |= dump_node_label(F, n);
/* Causes indeterministic output: if (is_Block(n)) fprintf (F, "\t ->%d", (int)get_irn_link(n)); */
if (has_backedges(n)) fprintf(F, "\t loop head!");
} else { /* for callgraph loop tree */
edge_label = 1;
/* if a filter is set, dump only the irg's that match the filter */
- if (strncmp(get_entity_name(get_irg_entity(irg)), dump_file_filter, strlen(dump_file_filter)) != 0)
- return;
+ if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg)))) return;
current_ir_graph = irg;
/* dump the nodes that go into the block */
for (n = get_irn_link(b); n; n = get_irn_link(n)) {
- if (eset_contains(extnodes, n)) overrule_nodecolor = "lightblue";
+ if (eset_contains(extnodes, n))
+ overrule_nodecolor = ird_color_lightblue;
dump_node(F, n);
- overrule_nodecolor = NULL;
+ overrule_nodecolor = ird_color_default;
if (!eset_contains(extnodes, n)) dump_ir_data_edges(F, n);
}
/* dump the nodes that go into the block */
for (n = get_irn_link(b); n; n = get_irn_link(n)) {
- if (!eset_contains(loopnodes, n)) overrule_nodecolor = "lightblue";
+ if (!eset_contains(loopnodes, n))
+ overrule_nodecolor = ird_color_lightblue;
dump_node(F, n);
- overrule_nodecolor = NULL;
+ overrule_nodecolor = ird_color_default;
if (eset_contains(loopnodes, n)) dump_ir_data_edges(F, n);
}