* @brief Write vcg representation of firm to file.
* @author Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Hubert Schmidt,
* Matthias Braun
- * @version $Id$
*/
#include "config.h"
#include "pset.h"
#include "util.h"
+typedef struct pns_lookup {
+ long nr; /**< the proj number */
+ const char *name; /**< the name of the Proj */
+} pns_lookup_t;
+
+typedef struct proj_lookup {
+ unsigned code; /**< the opcode of the Proj predecessor */
+ unsigned num_data; /**< number of data entries */
+ const pns_lookup_t *data; /**< the data */
+} proj_lookup_t;
+
+#include "gen_irdump.c.inl"
+
/** Dump only irgs with names that start with this prefix. */
static ident *dump_file_filter_id = NULL;
/* global and ahead declarations */
/*-----------------------------------------------------------------*/
-static void dump_node_with_edges(ir_node *n, void *env);
static void dump_loop_nodes_into_graph(FILE *F, ir_graph *irg);
/*-----------------------------------------------------------------*/
}
break;
- case iro_Proj: {
- ir_node *pred = get_Proj_pred(n);
-
- if (get_irn_opcode(pred) == iro_Cond
- && get_Proj_proj(n) == get_Cond_default_proj(pred)
- && get_irn_mode(get_Cond_selector(pred)) != mode_b)
- fprintf(F, "defProj");
- else
- goto default_case;
- } break;
-
case iro_Load:
if (get_Load_unaligned(n) == align_non_aligned)
fprintf(F, "ua");
fprintf(F, "%s", get_irn_opname(n));
break;
case iro_Block:
- if (is_Block_dead(n))
- fputs("Dead ", F);
if (n == get_irg_start_block(get_irn_irg(n)))
fputs("Start ", F);
if (n == get_irg_end_block(get_irn_irg(n)))
break;
default:
-default_case:
fprintf(F, "%s", get_irn_opname(n));
}
}
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 {
- unsigned code; /**< the opcode of the Proj predecessor */
- unsigned num_data; /**< number of data entries */
- const pns_lookup_t *data; /**< the data */
-} proj_lookup_t;
-
-/** 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_tls),
- X(T_args),
-#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),
- X(X_regular),
- X(X_except),
- X(T_result),
- X(P_value_res_base)
-#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),
-#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),
-#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) ARRAY_SIZE(a), a
- { iro_Start, E(start_lut) },
- { iro_Cond, E(cond_lut) },
- { iro_Call, E(call_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.
*/
break;
default:
- ;
- } /* end switch */
+ break;
+ }
}
-#include <math.h>
-#include "execution_frequency.h"
-
static void dump_node_ana_vals(FILE *F, ir_node *n)
{
(void) F;
}
}
-void dump_vrp_info(FILE *F, ir_node *n)
-{
- vrp_attr *vrp = vrp_get_info(n);
- if (n == NULL) {
- return;
- }
-
- fprintf(F, "range_type: %d\n", (int) vrp->range_type);
- if (vrp->range_type == VRP_RANGE || vrp->range_type ==
- VRP_ANTIRANGE) {
- ir_fprintf(F, "range_bottom: %F\n",vrp->range_bottom);
- ir_fprintf(F, "range_top: %F\n", vrp->range_top);
- }
- ir_fprintf(F, "bits_set: %T\n", vrp->bits_set);
- ir_fprintf(F, "bits_not_set: %T\n", vrp->bits_not_set);
-}
-
/**
* Dumps the attributes of a node n into the file F.
* Currently this is only the color of a node.
print_vcg_color(F, ird_color_error);
break;
case iro_Block:
- if (is_Block_dead(n))
- print_vcg_color(F, ird_color_dead_block_background);
- else
- print_vcg_color(F, ird_color_block_background);
+ print_vcg_color(F, ird_color_block_background);
break;
case iro_Phi:
print_vcg_color(F, ird_color_phi);
void *dump_add_node_info_callback(dump_node_info_cb_t *cb, void *data)
{
- hook_entry_t *info = XMALLOC(hook_entry_t);
+ hook_entry_t *info = XMALLOCZ(hook_entry_t);
info->hook._hook_node_info = cb;
info->context = data;
for (i = 0; i < get_irn_arity(n); i++) {
ir_node *con = get_irn_n(n, i);
- if (is_constlike_node(con) && !irn_visited(con)) {
- mark_irn_visited(con);
+ if (is_constlike_node(con) && !irn_visited_else_mark(con)) {
/* Generate a new name for the node by appending the names of
n and const. */
fprintf(F, "node: {title: "); PRINT_CONSTID(n, con);
/* colorize blocks */
if (! get_Block_matured(block))
color = ird_color_block_background;
- if (is_Block_dead(block))
- color = ird_color_dead_block_background;
fprintf(F, "\" status:clustered ");
print_vcg_color(F, color);
dump_ir_edges(node, F);
}
- if ((flags & ir_dump_flag_loops) && (get_irg_loopinfo_state(irg) & loopinfo_valid))
+ if ((flags & ir_dump_flag_loops)
+ && is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_LOOPINFO))
dump_loop_nodes_into_graph(F, irg);
current_ir_graph = rem;
{
fprintf(F, "info1: \"");
dump_entity_to_file(F, get_irg_entity(irg));
+ fprintf(F, "\n");
+
+ /* dump graph state */
+ fprintf(F, "state:");
+ if (is_irg_state(irg, IR_GRAPH_STATE_ARCH_DEP))
+ fprintf(F, " arch_dep");
+ if (is_irg_state(irg, IR_GRAPH_STATE_MODEB_LOWERED))
+ fprintf(F, " modeb_lowered");
+ if (is_irg_state(irg, IR_GRAPH_STATE_NORMALISATION2))
+ fprintf(F, " normalisation2");
+ if (is_irg_state(irg, IR_GRAPH_STATE_IMPLICIT_BITFIELD_MASKING))
+ fprintf(F, " implicit_bitfield_masking");
+ if (is_irg_state(irg, IR_GRAPH_STATE_OPTIMIZE_UNREACHABLE_CODE))
+ fprintf(F, " optimize_unreachable_code");
+ if (is_irg_state(irg, IR_GRAPH_STATE_NO_CRITICAL_EDGES))
+ fprintf(F, " no_critical_edges");
+ if (is_irg_state(irg, IR_GRAPH_STATE_NO_BADS))
+ fprintf(F, " no_bads");
+ if (is_irg_state(irg, IR_GRAPH_STATE_NO_UNREACHABLE_CODE))
+ fprintf(F, " no_unreachable_code");
+ if (is_irg_state(irg, IR_GRAPH_STATE_ONE_RETURN))
+ fprintf(F, " one_return");
+ if (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_DOMINANCE))
+ fprintf(F, " consistent_dominance");
+ if (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_POSTDOMINANCE))
+ fprintf(F, " consistent_postdominance");
+ if (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_OUT_EDGES))
+ fprintf(F, " consistent_out_edges");
+ if (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_OUTS))
+ fprintf(F, " consistent_outs");
+ if (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_LOOPINFO))
+ fprintf(F, " consistent_loopinfo");
+ if (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_ENTITY_USAGE))
+ fprintf(F, " consistent_entity_usage");
+ if (is_irg_state(irg, IR_GRAPH_STATE_VALID_EXTENDED_BLOCKS))
+ fprintf(F, " valid_exended_blocks");
fprintf(F, "\"\n");
}
break;
default:
break;
- } /* switch type */
+ }
}
#endif
break;
default:
break;
- } /* switch type */
+ }
}
void dump_type_node(FILE *F, ir_type *tp)
{
fprintf(F, "node: {title: ");
PRINT_TYPEID(tp);
- fprintf(F, " label: \"%s ", get_type_tpop_name(tp));
+ fprintf(F, " label: \"");
if (tp->dbi != NULL) {
- char buf[256];
+ char buf[1024];
ir_print_type(buf, sizeof(buf), tp);
- fprintf(F, "'%s'", buf);
+ fprintf(F, "%s '%s'", get_type_tpop_name(tp), buf);
} else {
ir_fprintf(F, "%+F", tp);
}
(void) ent;
}
-/** Dumps a type or entity and its edges. */
+/**
+ * type-walker: Dumps a type or entity and its edges.
+ */
static void dump_type_info(type_or_ent tore, void *env)
{
FILE *F = (FILE*)env;
--i;
upper = get_array_upper_bound(tp, i);
lower = get_array_lower_bound(tp, i);
- print_node_type_edge(F, upper, tp, "label: \"upper %d\"", get_array_order(tp, i));
- print_node_type_edge(F, lower, tp, "label: \"lower %d\"", get_array_order(tp, i));
+ print_node_type_edge(F, upper, tp, "label: \"upper %zu\"", get_array_order(tp, i));
+ print_node_type_edge(F, lower, tp, "label: \"lower %zu\"", get_array_order(tp, i));
dump_const_expression(F, upper);
dump_const_expression(F, lower);
}
break;
default:
break;
- } /* switch type */
+ }
break; /* case k_type */
}
default:
printf(" *** irdump, dump_type_info(l.%i), faulty type.\n", __LINE__);
- } /* switch kind_or_entity */
+ }
}
/** For dumping class hierarchies.
}
break;
default: break;
- } /* switch type */
+ }
break; /* case k_type */
}
default:
printf(" *** irdump, dump_class_hierarchy_node(l.%i), faulty type.\n", __LINE__);
- } /* switch kind_or_entity */
+ }
}
/*******************************************************************/
}
}
-static void dump_loop_label(FILE *F, ir_loop *loop)
+static void dump_loop_label(FILE *F, const ir_loop *loop)
{
- fprintf(F, "loop %u, %lu sons, %lu nodes",
- get_loop_depth(loop), (unsigned long) get_loop_n_sons(loop),
- (unsigned long) get_loop_n_nodes(loop));
+ fprintf(F, "loop %u", get_loop_depth(loop));
}
-static void dump_loop_info(FILE *F, ir_loop *loop)
+static void dump_loop_info(FILE *F, const ir_loop *loop)
{
fprintf(F, " info1: \"");
fprintf(F, " loop nr: %ld", get_loop_loop_nr(loop));
fprintf(F, "\"");
}
-static void dump_loop_node(FILE *F, ir_loop *loop)
+static void dump_loop_node(FILE *F, const ir_loop *loop)
{
fprintf(F, "node: {title: \"");
PRINT_LOOPID(loop);
fprintf(F, "}\n");
}
-static void dump_loop_node_edge(FILE *F, ir_loop *loop, size_t i)
+static void dump_loop_node_edge(FILE *F, const ir_loop *loop, size_t i)
{
assert(loop);
fprintf(F, "edge: {sourcename: \"");
PRINT_LOOPID(loop);
fprintf(F, "\" targetname: \"");
- PRINT_NODEID(get_loop_node(loop, i));
+ PRINT_NODEID(get_loop_element(loop, i).node);
fprintf(F, "\" color: green");
fprintf(F, "}\n");
}
-static void dump_loop_son_edge(FILE *F, ir_loop *loop, size_t i)
+static void dump_loop_son_edge(FILE *F, const ir_loop *loop, size_t i)
{
assert(loop);
fprintf(F, "edge: {sourcename: \"");
PRINT_LOOPID(loop);
fprintf(F, "\" targetname: \"");
- PRINT_LOOPID(get_loop_son(loop, i));
- ir_fprintf(F, "\" color: darkgreen label: \"%zu\"}\n",
- get_loop_element_pos(loop, get_loop_son(loop, i)));
+ PRINT_LOOPID(get_loop_element(loop, i).son);
+ ir_fprintf(F, "\" color: darkgreen label: \"%zu\"}\n", i);
}
-static void dump_loops(FILE *F, ir_loop *loop)
+static void dump_loops(FILE *F, const ir_loop *loop)
{
size_t i;
+ size_t n_elements = get_loop_n_elements(loop);
/* dump this loop node */
dump_loop_node(F, loop);
/* dump edges to nodes in loop -- only if it is a real loop */
if (get_loop_depth(loop) != 0) {
- for (i = get_loop_n_nodes(loop); i > 0;) {
+ for (i = n_elements; i > 0;) {
+ loop_element element;
--i;
+ element = get_loop_element(loop, i);
+ if (*element.kind != k_ir_node)
+ continue;
dump_loop_node_edge(F, loop, i);
}
}
- for (i = get_loop_n_sons(loop); i > 0;) {
- --i;
- dump_loops(F, get_loop_son(loop, i));
+ for (i = n_elements; i > 0;) {
+ loop_element element;
+ --i;
+ element = get_loop_element(loop, i);
+ if (*element.kind != k_ir_loop)
+ continue;
+ dump_loops(F, element.son);
dump_loop_son_edge(F, loop, i);
}
}
* from irg.
*/
for (i = get_irp_n_irgs(); i > 0;) {
- ir_graph *irg = get_irp_irg(--i);
- ir_node **arr = (ir_node**)ird_get_irg_link(irg);
+ ir_graph *other_irg = get_irp_irg(--i);
+ ir_node **arr = (ir_node**)ird_get_irg_link(other_irg);
if (arr == NULL)
continue;
- dump_graph_from_list(out, irg);
+ dump_graph_from_list(out, other_irg);
DEL_ARR_F(arr);
}
}
}
if ((flags & ir_dump_flag_loops)
- && (get_irg_loopinfo_state(irg) & loopinfo_valid))
+ && (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_LOOPINFO)))
dump_loop_nodes_into_graph(F, irg);
current_ir_graph = rem;
size_t i;
ir_entity *ent = get_irg_entity(irg);
- if (get_irg_extblk_state(irg) != ir_extblk_info_valid)
+ if (!is_irg_state(irg, IR_GRAPH_STATE_VALID_EXTENDED_BLOCKS))
compute_extbb(irg);
construct_extblock_lists(irg);
print_dbg_info(F, get_entity_dbg_info(ent));
for (i = get_irp_n_irgs(); i > 0;) {
- ir_graph *irg = get_irp_irg(--i);
- list_tuple *lists = (list_tuple*)ird_get_irg_link(irg);
+ ir_graph *other_irg = get_irp_irg(--i);
+ list_tuple *lists = (list_tuple*)ird_get_irg_link(other_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);
+ ird_set_irg_link(other_irg, lists->extbb_list);
+ dump_extblock_graph(F, other_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);
+ ird_set_irg_link(other_irg, lists->blk_list);
+ dump_block_graph(F, other_irg);
}
DEL_ARR_F(lists->extbb_list);
/* dump the out edges in a separate walk */
if ((flags & ir_dump_flag_out_edges)
- && (get_irg_outs_state(irg) != outs_none)) {
+ && (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_OUTS))) {
irg_out_walk(get_irg_start(irg), dump_out_edge, NULL, out);
}
static void dump_block_to_cfg(ir_node *block, void *env)
{
FILE *F = (FILE*)env;
- int i, fl = 0;
- ir_node *pred;
+ int i;
+
+ if (is_Bad(block) && get_irn_mode(block) == mode_X) {
+ dump_node(F, block);
+ }
if (is_Block(block)) {
/* This is a block. Dump a node for the block. */
/* the generic version. */
dump_irnode_to_file(F, block);
- /* Check whether we have bad predecessors to color the block. */
- for (i = get_Block_n_cfgpreds(block) - 1; i >= 0; --i)
- if ((fl = is_Bad(get_Block_cfgpred(block, i))))
- break;
-
fprintf(F, "\""); /* closing quote of info */
if ((block == get_irg_start_block(get_irn_irg(block))) ||
(block == get_irg_end_block(get_irn_irg(block))) )
fprintf(F, " color:blue ");
- else if (fl)
- fprintf(F, " color:yellow ");
fprintf(F, "}\n");
+
/* Dump the edges */
- for (i = get_Block_n_cfgpreds(block) - 1; i >= 0; --i)
- if (!is_Bad(skip_Proj(get_Block_cfgpred(block, i)))) {
- pred = get_nodes_block(skip_Proj(get_Block_cfgpred(block, i)));
- fprintf(F, "edge: { sourcename: \"");
- PRINT_NODEID(block);
- fprintf(F, "\" targetname: \"");
- PRINT_NODEID(pred);
- fprintf(F, "\"}\n");
- }
+ for (i = get_Block_n_cfgpreds(block) - 1; i >= 0; --i) {
+ ir_node *pred = get_Block_cfgpred(block, i);
+ if (!is_Bad(pred))
+ pred = get_nodes_block(pred);
+ fprintf(F, "edge: { sourcename: \"");
+ PRINT_NODEID(block);
+ fprintf(F, "\" targetname: \"");
+ PRINT_NODEID(pred);
+ fprintf(F, "\"}\n");
+ }
/* Dump dominator/postdominator edge */
if (ir_get_dump_flags() & ir_dump_flag_dominance) {
- if (get_irg_dom_state(current_ir_graph) == dom_consistent && get_Block_idom(block)) {
- pred = get_Block_idom(block);
+ if (is_irg_state(get_irn_irg(block), IR_GRAPH_STATE_CONSISTENT_DOMINANCE) && get_Block_idom(block)) {
+ ir_node *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);
+ if (is_irg_state(get_irn_irg(block), IR_GRAPH_STATE_CONSISTENT_POSTDOMINANCE) && get_Block_ipostdom(block)) {
+ ir_node *pred = get_Block_ipostdom(block);
fprintf(F, "edge: { sourcename: \"");
PRINT_NODEID(block);
fprintf(F, "\" targetname: \"");
dump_vcg_header(F, get_irg_dump_name(irg), NULL, NULL);
/* 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));
+ irg_walk_graph(irg, dump_block_to_cfg, NULL, F);
dump_vcg_footer(F);
}
PRINT_NODEID(b);
fprintf(F, "\" label: \"");
dump_node_opcode(F, b);
- fprintf(F, " %ld:%d", get_irn_node_nr(b), get_irn_idx(b));
+ fprintf(F, " %ld:%u", get_irn_node_nr(b), get_irn_idx(b));
fprintf(F, "\" status:clustered color:yellow\n");
/* dump the blocks edges */
PRINT_NODEID(b);
fprintf(F, "\" label: \"");
dump_node_opcode(F, b);
- fprintf(F, " %ld:%d", get_irn_node_nr(b), get_irn_idx(b));
+ fprintf(F, " %ld:%u", get_irn_node_nr(b), get_irn_idx(b));
fprintf(F, "\" status:clustered color:lightblue\n");
/* dump the nodes that go into the block */
projects / libfirm / blobdiff