* @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 <errno.h>
#include "list.h"
+#include "pset.h"
#include "irnode_t.h"
#include "irgraph_t.h"
#include "array.h"
#include "pmap.h"
#include "obst.h"
-#include "eset.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;
/** Initializes the used colors. */
static void init_colors(void)
{
- static int initialized = 0;
+ static bool initialized = 0;
if (initialized)
return;
fprintf(out, "color:%s", color_names[color]);
}
+void print_nodeid(FILE *F, const ir_node *node)
+{
+ fprintf(F, "\"n%ld\"", get_irn_node_nr(node));
+}
+
+void print_irgid(FILE *F, const ir_graph *irg)
+{
+ fprintf(F, "\"g%ld\"", get_irg_graph_nr(irg));
+}
+
+void print_typeid(FILE *F, const ir_type *type)
+{
+ fprintf(F, "\"t%ld\"", get_type_nr(type));
+}
+
+void print_entityid(FILE *F, const ir_entity *entity)
+{
+ fprintf(F, "\"e%ld\"", get_entity_nr(entity));
+}
+
+static void print_itemid(FILE *F, const ir_type *tp, size_t itemnr)
+{
+ fprintf(F, "\"i%ldT%zu\"", get_type_nr(tp), itemnr);
+}
+
/**
* Prints the edge kind of a given IR node.
*
* Projs should be dumped near their predecessor, so they get "nearedge".
*/
-static void print_node_edge_kind(FILE *out, ir_node *node)
+static void print_node_edge_kind(FILE *out, const ir_node *node)
{
if (is_Proj(node)) {
fprintf(out, "nearedge: ");
va_list ap;
va_start(ap, fmt);
- fprintf(F, "edge: { sourcename: "); PRINT_TYPEID(S);
- fprintf(F, " targetname: "); PRINT_TYPEID(T);
+ fprintf(F, "edge: { sourcename: ");
+ print_typeid(F, S);
+ fprintf(F, " targetname: ");
+ print_typeid(F, T);
ir_vfprintf(F, fmt, ap);
fprintf(F,"}\n");
va_end(ap);
va_list ap;
va_start(ap, fmt);
- fprintf(F, "edge: { sourcename: "); PRINT_TYPEID(tp);
- fprintf(F, " targetname: \""); PRINT_ENTID(ent); fprintf(F, "\"");
+ fprintf(F, "edge: { sourcename: ");
+ print_typeid(F, tp);
+ fprintf(F, " targetname: ");
+ print_entityid(F, ent);
ir_vfprintf(F, fmt, ap);
fprintf(F, "}\n");
va_end(ap);
va_start(ap, fmt);
if (backedge)
- fprintf(F, "backedge: { sourcename: \"");
+ fprintf(F, "backedge: { sourcename: ");
else
- fprintf(F, "edge: { sourcename: \"");
- PRINT_ENTID(ent1);
- fprintf(F, "\" targetname: \""); PRINT_ENTID(ent2); fprintf(F, "\"");
+ fprintf(F, "edge: { sourcename: ");
+ print_entityid(F, ent1);
+ fprintf(F, " targetname: ");
+ print_entityid(F, ent2);
ir_vfprintf(F, fmt, ap);
fprintf(F, " ");
if (color != ird_color_none)
va_list ap;
va_start(ap, fmt);
- fprintf(F, "edge: { sourcename: \""); PRINT_ENTID(ent);
- fprintf(F, "\" targetname: "); PRINT_TYPEID(tp);
+ fprintf(F, "edge: { sourcename: ");
+ print_entityid(F, ent);
+ fprintf(F, " targetname: ");
+ print_typeid(F, tp);
ir_vfprintf(F, fmt, ap);
fprintf(F,"}\n");
va_end(ap);
va_list ap;
va_start(ap, fmt);
- fprintf(F, "edge: { sourcename: \""); PRINT_NODEID(irn);
- fprintf(F, "\" targetname: "); PRINT_TYPEID(tp);
+ fprintf(F, "edge: { sourcename: ");
+ print_nodeid(F, irn);
+ fprintf(F, " targetname: ");
+ print_typeid(F, tp);
ir_vfprintf(F, fmt, ap);
fprintf(F,"}\n");
va_end(ap);
va_list ap;
va_start(ap, fmt);
- fprintf(F, "edge: { sourcename: \""); PRINT_NODEID(irn);
- fprintf(F, "\" targetname: \""); PRINT_ENTID(ent);
- fprintf(F, "\"");
+ fprintf(F, "edge: { sourcename: ");
+ print_nodeid(F, irn);
+ fprintf(F, " targetname: ");
+ print_entityid(F, ent);
ir_vfprintf(F, fmt, ap);
fprintf(F,"}\n");
va_end(ap);
va_list ap;
va_start(ap, fmt);
- fprintf(F, "edge: { sourcename: \""); PRINT_ENTID(ent);
- fprintf(F, "\" targetname: \""); PRINT_NODEID(irn); fprintf(F, "\"");
+ fprintf(F, "edge: { sourcename: ");
+ print_entityid(F, ent);
+ fprintf(F, "\" targetname: ");
+ print_nodeid(F, irn);
ir_vfprintf(F, fmt, ap);
fprintf(F,"}\n");
va_end(ap);
va_list ap;
va_start(ap, fmt);
- fprintf(F, "edge: { sourcename: "); PRINT_TYPEID(tp);
- fprintf(F, " targetname: \""); PRINT_ITEMID(tp, item); fprintf(F, "\" ");
+ fprintf(F, "edge: { sourcename: ");
+ print_typeid(F, tp);
+ fprintf(F, " targetname: ");
+ print_itemid(F, tp, item);
ir_vfprintf(F, fmt, ap);
fprintf(F,"}\n");
va_end(ap);
* If the entity has a ld_name, returns it if the dump_ld_name is set,
* else returns the name of the entity.
*/
-static const char *_get_ent_dump_name(const ir_entity *ent, bool dump_ld_name)
+static const char *get_ent_dump_name_(const ir_entity *ent, bool dump_ld_name)
{
if (ent == NULL)
return "<NULL entity>";
const char *get_ent_dump_name(const ir_entity *ent)
{
- return _get_ent_dump_name(ent, flags & ir_dump_flag_ld_names);
+ return get_ent_dump_name_(ent, flags & ir_dump_flag_ld_names);
}
const char *get_irg_dump_name(const ir_graph *irg)
{
/* Don't use get_entity_ld_ident (ent) as it computes the mangled name! */
- return _get_ent_dump_name(get_irg_entity(irg), true);
+ return get_ent_dump_name_(get_irg_entity(irg), true);
}
/**
return lists;
}
-void dump_node_opcode(FILE *F, ir_node *n)
+void dump_node_opcode(FILE *F, const ir_node *n)
{
const ir_op_ops *ops = get_op_ops(get_irn_op(n));
case symconst_ofs_ent:
fprintf(F, "SymC %s offset", get_entity_name(get_SymConst_entity(n)));
break;
- case symconst_type_tag:
- ir_fprintf(F, "SymC %+F tag", get_SymConst_type(n));
- break;
case symconst_type_size:
ir_fprintf(F, "SymC %+F size", get_SymConst_type(n));
break;
}
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");
break;
default:
-default_case:
fprintf(F, "%s", get_irn_opname(n));
}
}
* Dump the mode of a node n to a file F.
* Ignore modes that are "always known".
*/
-static void dump_node_mode(FILE *F, ir_node *n)
+static void dump_node_mode(FILE *F, const ir_node *n)
{
const ir_op_ops *ops = get_op_ops(get_irn_op(n));
unsigned iro;
/**
* Dump the type of a node n to a file F if it's known.
*/
-static int dump_node_typeinfo(FILE *F, ir_node *n)
+static int dump_node_typeinfo(FILE *F, const ir_node *n)
{
int bad = 0;
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) {
+ if (tp != get_none_type()) {
ir_fprintf(F, "[%+F]", tp);
} 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 {
- 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(M),
- X(P_frame_base),
- 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),
-#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.
*/
-static void dump_node_nodeattr(FILE *F, ir_node *n)
+static void dump_node_nodeattr(FILE *F, const ir_node *n)
{
ir_node *pred;
unsigned code;
default:
break;
- } /* end switch */
-}
-
-static void dump_node_ana_vals(FILE *F, ir_node *n)
-{
- (void) F;
- (void) n;
- return;
+ }
}
-void dump_node_label(FILE *F, ir_node *n)
+void dump_node_label(FILE *F, const ir_node *n)
{
dump_node_opcode(F, n);
fputs(" ", 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.
*/
-static void dump_node_vcgattr(FILE *F, ir_node *node, ir_node *local, int bad)
+static void dump_node_vcgattr(FILE *F, const ir_node *node, const ir_node *local, bool bad)
{
ir_mode *mode;
- ir_node *n;
+ const ir_node *n;
if (bad) {
print_vcg_color(F, ird_color_error);
/**
* Dump the node information of a node n to a file F.
*/
-static void dump_node_info(FILE *F, ir_node *n)
+static void dump_node_info(FILE *F, const ir_node *n)
{
const ir_op_ops *ops = get_op_ops(get_irn_op(n));
return is_op_constlike(op);
}
+static void print_constid(FILE *F, const ir_node *user, const ir_node *node)
+{
+ fprintf(F, "\"n%ldb%ld\"", get_irn_node_nr(user), get_irn_node_nr(node));
+}
+
+static void print_constblkid(FILE *F, const ir_node *node, const ir_node *block)
+{
+ fprintf(F, "\"n%ldb%ld\"", get_irn_node_nr(node), get_irn_node_nr(block));
+}
+
/** outputs the predecessors of n, that are constants, local. I.e.,
generates a copy of the constant predecessors for each node called with. */
-static void dump_const_node_local(FILE *F, ir_node *n)
+static void dump_const_node_local(FILE *F, const ir_node *n)
{
int i;
if (!get_opt_dump_const_local()) return;
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);
+ fprintf(F, "node: {title: ");
+ print_constid(F, n, con);
fprintf(F, " label: \"");
dump_node_label(F, con);
fprintf(F, "\" ");
}
/** If the block of an edge is a const_like node, dump it local with an edge */
-static void dump_const_block_local(FILE *F, ir_node *n)
+static void dump_const_block_local(FILE *F, const ir_node *n)
{
ir_node *blk;
if (is_constlike_node(blk)) {
/* 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: \"");
+ fprintf(F, "node: {title: ");
+ print_constblkid(F, n, blk);
+ fprintf(F, " label: \"");
dump_node_label(F, blk);
fprintf(F, "\" ");
dump_node_info(F, blk);
dump_node_vcgattr(F, n, blk, 0);
fprintf(F, "}\n");
- fprintf(F, "edge: { sourcename: \"");
- PRINT_NODEID(n);
- fprintf(F, "\" targetname: \""); PRINT_CONSTBLKID(n,blk);
+ fprintf(F, "edge: { sourcename: ");
+ print_nodeid(F, n);
+ fprintf(F, " targetname: ");
+ print_constblkid(F, n, blk);
+ 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;
- }
+ if (dump_edge_vcgattr_hook != NULL
+ && dump_edge_vcgattr_hook(F, n, -1)) {
+ fprintf(F, "}\n");
+ return;
}
- fprintf(F, "\" " BLOCK_EDGE_ATTR "}\n");
+ fprintf(F, BLOCK_EDGE_ATTR "}\n");
}
}
/**
* Dump a node
*/
-static void dump_node(FILE *F, ir_node *n)
+void dump_node(FILE *F, const ir_node *n)
{
int bad = 0;
const char *p;
return;
/* dump this node */
- fputs("node: {title: \"", F);
- PRINT_NODEID(n);
- fputs("\"", F);
+ fputs("node: {title: ", F);
+ print_nodeid(F, n);
fputs(" label: \"", F);
bad = ! irn_verify_irg_dump(n, current_ir_graph, &p);
dump_node_label(F, n);
- dump_node_ana_vals(F, n);
- //dump_node_ana_info(F, n);
fputs("\" ", F);
- if (get_op_flags(get_irn_op(n)) & irop_flag_dump_noinput) {
- //fputs(" node_class:23", F);
- }
-
dump_node_info(F, n);
print_node_error(F, p);
print_dbg_info(F, get_irn_dbg_info(n));
fputs("}\n", F);
dump_const_node_local(F, n);
- if (dump_node_edge_hook)
- dump_node_edge_hook(F, n);
}
/** dump the edge to the block this node belongs to */
-static void dump_ir_block_edge(FILE *F, ir_node *n)
+static void dump_ir_block_edge(FILE *F, const ir_node *n)
{
if (get_opt_dump_const_local() && is_constlike_node(n)) return;
if (!is_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, "edge: { sourcename: ");
+ print_nodeid(F, n);
+ fprintf(F, " targetname: ");
+ print_nodeid(F, block);
+ fprintf(F, " ");
+
+ if (dump_edge_vcgattr_hook && dump_edge_vcgattr_hook(F, n, -1)) {
+ fprintf(F, "}\n");
+ return;
}
- fprintf(F, " " BLOCK_EDGE_ATTR "}\n");
+ fprintf(F, BLOCK_EDGE_ATTR "}\n");
}
}
}
-static void print_data_edge_vcgattr(FILE *F, ir_node *from, int to)
+static void print_data_edge_vcgattr(FILE *F, const ir_node *from, int to)
{
/*
* do not use get_nodes_block() here, will fail
fprintf(F, INTER_DATA_EDGE_ATTR);
}
-static void print_mem_edge_vcgattr(FILE *F, ir_node *from, int to)
+static void print_mem_edge_vcgattr(FILE *F, const ir_node *from, int to)
{
/*
* do not use get_nodes_block() here, will fail
}
/** Print the vcg attributes for the edge from node "from" to its "to"th input */
-static void print_edge_vcgattr(FILE *F, ir_node *from, int to)
+static void print_edge_vcgattr(FILE *F, const ir_node *from, int to)
{
assert(from);
}
/** dump edges to our inputs */
-static void dump_ir_data_edges(FILE *F, ir_node *n)
+static void dump_ir_data_edges(FILE *F, const ir_node *n)
{
int i, num;
+ if (dump_node_edge_hook)
+ dump_node_edge_hook(F, n);
+
if (!(flags & ir_dump_flag_keepalive_edges) && is_End(n)) {
/* the End node has only keep-alive edges */
return;
if (dep) {
print_node_edge_kind(F, n);
- fprintf(F, "{sourcename: \"");
- PRINT_NODEID(n);
- fprintf(F, "\" targetname: ");
+ fprintf(F, "{sourcename: ");
+ print_nodeid(F, n);
+ fprintf(F, " targetname: ");
if ((get_opt_dump_const_local()) && is_constlike_node(dep)) {
- PRINT_CONSTID(n, dep);
+ print_constid(F, n, dep);
} else {
- fprintf(F, "\"");
- PRINT_NODEID(dep);
- fprintf(F, "\"");
+ print_nodeid(F, dep);
}
fprintf(F, " label: \"%d\" ", i);
fprintf(F, " color: darkgreen}\n");
assert(pred);
if ((flags & ir_dump_flag_back_edges) && is_backedge(n, i)) {
- fprintf(F, "backedge: {sourcename: \"");
+ fprintf(F, "backedge: {sourcename: ");
} else {
print_node_edge_kind(F, n);
- fprintf(F, "{sourcename: \"");
+ fprintf(F, "{sourcename: ");
}
- PRINT_NODEID(n);
- fprintf(F, "\" targetname: ");
+ print_nodeid(F, n);
+ fprintf(F, " targetname: ");
if ((get_opt_dump_const_local()) && is_constlike_node(pred)) {
- PRINT_CONSTID(n, pred);
+ print_constid(F, n, pred);
} else {
- fprintf(F, "\""); PRINT_NODEID(pred); fprintf(F, "\"");
+ print_nodeid(F, pred);
}
fprintf(F, " label: \"%d\" ", i);
print_edge_vcgattr(F, n, i);
ir_node *succ = get_edge_src_irn(edge);
print_node_edge_kind(F, succ);
- fprintf(F, "{sourcename: \"");
- PRINT_NODEID(node);
- fprintf(F, "\" targetname: \"");
- PRINT_NODEID(succ);
- fprintf(F, "\"");
+ fprintf(F, "{sourcename: ");
+ print_nodeid(F, node);
+ fprintf(F, " targetname: ");
+ print_nodeid(F, succ);
fprintf(F, " label: \"%d\" ", i);
fprintf(F, OUT_EDGE_ATTR);
/** Dumps a node and its edges but not the block edge */
-static void dump_node_wo_blockedge(ir_node *n, void *env)
+static void dump_node_wo_blockedge(FILE *F, const ir_node *n)
{
- FILE *F = (FILE*)env;
dump_node(F, n);
dump_ir_data_edges(F, n);
}
static void dump_node_with_edges(ir_node *n, void *env)
{
FILE *F = (FILE*)env;
- dump_node_wo_blockedge(n, env);
+ dump_node_wo_blockedge(F, n);
if (!node_floats(n))
dump_ir_block_edge(F, n);
}
/** Dumps a const-like node. */
static void dump_const_node(ir_node *n, void *env)
{
+ FILE *F = (FILE*)env;
if (is_Block(n)) return;
- dump_node_wo_blockedge(n, env);
+ dump_node_wo_blockedge(F, n);
}
/***********************************************************************/
* Expects to find nodes belonging to the block as list in its
* link field.
* Dumps the edges of all nodes including itself. */
-static void dump_whole_block(FILE *F, ir_node *block)
+static void dump_whole_block(FILE *F, const ir_node *block)
{
ir_node *node;
ird_color_t color = ird_color_block_background;
assert(is_Block(block));
- fprintf(F, "graph: { title: \"");
- PRINT_NODEID(block);
- fprintf(F, "\" label: \"");
+ fprintf(F, "graph: { title: ");
+ print_nodeid(F, block);
+ fprintf(F, " label: \"");
dump_node_label(F, block);
/* colorize blocks */
{
ir_entity *ent = get_irg_entity(irg);
- fprintf(F, "graph: { title: \"");
- PRINT_IRGID(irg);
- fprintf(F, "\" label: \"%s\" status:clustered color:%s \n",
+ fprintf(F, "graph: { title: ");
+ print_irgid(F, irg);
+ fprintf(F, " label: \"%s\" status:clustered color:%s\n",
get_ent_dump_name(ent), color_names[ird_color_prog_background]);
dump_graph_info(F, irg);
}
}
-#if 0
-static int print_type_info(FILE *F, ir_type *tp)
-{
- int bad = 0;
-
- if (get_type_state(tp) == layout_undefined) {
- fprintf(F, "state: layout_undefined\n");
- } else {
- fprintf(F, "state: layout_fixed,\n");
- }
- if (get_type_mode(tp))
- fprintf(F, "mode: %s,\n", get_mode_name_ex(get_type_mode(tp), &bad));
- fprintf(F, "size: %db,\n", get_type_size_bits(tp));
-
- return bad;
-}
-
-static void print_typespecific_info(FILE *F, ir_type *tp)
-{
- switch (get_type_tpop_code(tp)) {
- case tpo_class:
- fprintf(F, "peculiarity: %s\n", get_peculiarity_string(get_class_peculiarity(tp)));
- break;
- case tpo_struct:
- break;
- case tpo_method:
- fprintf(F, "variadicity: %s\n", get_variadicity_name(get_method_variadicity(tp)));
- fprintf(F, "params: %d\n", get_method_n_params(tp));
- fprintf(F, "results: %d\n", get_method_n_ress(tp));
- break;
- case tpo_union:
- break;
- case tpo_array:
- break;
- case tpo_enumeration:
- break;
- case tpo_pointer:
- break;
- case tpo_primitive:
- break;
- default:
- break;
- } /* switch type */
-}
-#endif
-
static void print_typespecific_vcgattr(FILE *F, ir_type *tp)
{
switch (get_type_tpop_code(tp)) {
break;
default:
break;
- } /* switch type */
+ }
}
void dump_type_node(FILE *F, ir_type *tp)
{
fprintf(F, "node: {title: ");
- PRINT_TYPEID(tp);
+ print_typeid(F, tp);
fprintf(F, " label: \"");
if (tp->dbi != NULL) {
char buf[1024];
static void dump_entity_node(FILE *F, ir_entity *ent)
{
- fprintf(F, "node: {title: \"");
- PRINT_ENTID(ent); fprintf(F, "\"");
+ fprintf(F, "node: {title: ");
+ print_entityid(F, ent);
fprintf(F, " label: ");
fprintf(F, "\"%s\" ", get_ent_dump_name(ent));
tarval_snprintf(buf, sizeof(buf), tv);
else
strncpy(buf, "<not set>", sizeof(buf));
- fprintf(F, "node: {title: \"");
- PRINT_ITEMID(tp, pos); fprintf(F, "\"");
+ fprintf(F, "node: {title: ");
+ print_itemid(F, tp, pos);
fprintf(F, " label: ");
fprintf(F, "\"enum item %s\" " ENUM_ITEM_NODE_ATTR, get_id_str(id));
fprintf(F, "\n info1: \"value: %s\"}\n", buf);
case tpo_pointer:
print_type_type_edge(F, tp, get_pointer_points_to_type(tp), PTR_PTS_TO_EDGE_ATTR);
break;
+ case tpo_unknown:
+ case tpo_code:
+ case tpo_uninitialized:
+ case tpo_none:
case tpo_primitive:
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 */
+ }
}
/*******************************************************************/
ir_node *succ = get_irn_out(n, i);
assert(succ);
print_node_edge_kind(F, succ);
- fprintf(F, "{sourcename: \"");
- PRINT_NODEID(n);
- fprintf(F, "\" targetname: \"");
- PRINT_NODEID(succ);
- fprintf(F, "\" color: red linestyle: dashed");
+ fprintf(F, "{sourcename: ");
+ print_nodeid(F, n);
+ fprintf(F, " targetname: ");
+ print_nodeid(F, succ);
+ fprintf(F, " color: red linestyle: dashed");
fprintf(F, "}\n");
}
}
-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));
-#ifdef DEBUG_libfirm /* GL @@@ debug analyses */
+#ifdef DEBUG_libfirm
fprintf(F, "\n The loop was analyzed %ld times.", (long int) PTR_TO_INT(get_loop_link(loop)));
#endif
fprintf(F, "\"");
}
-static void dump_loop_node(FILE *F, ir_loop *loop)
+void print_loopid(FILE *F, const ir_loop *loop)
+{
+ fprintf(F, "\"l%ld\"", get_loop_loop_nr(loop));
+}
+
+static void dump_loop_node(FILE *F, const ir_loop *loop)
{
- fprintf(F, "node: {title: \"");
- PRINT_LOOPID(loop);
- fprintf(F, "\" label: \"");
+ fprintf(F, "node: {title: ");
+ print_loopid(F, loop);
+ fprintf(F, " label: \"");
dump_loop_label(F, loop);
fprintf(F, "\" ");
dump_loop_info(F, 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));
- fprintf(F, "\" color: green");
+ fprintf(F, "edge: {sourcename: ");
+ print_loopid(F, loop);
+ fprintf(F, " targetname: ");
+ print_nodeid(F, 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)));
+ fprintf(F, "edge: {sourcename: ");
+ print_loopid(F, loop);
+ fprintf(F, " targetname: ");
+ print_loopid(F, 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);
}
}
}
}
+void dump_vcg_header_colors(FILE *F)
+{
+ int i;
+ init_colors();
+ for (i = 0; i < ird_color_count; ++i) {
+ if (color_rgb[i] != NULL) {
+ fprintf(F, "colorentry %s: %s\n", color_names[i], color_rgb[i]);
+ }
+ }
+}
+
+void dump_vcg_infonames(FILE *F)
+{
+ fputs(
+ "infoname 1: \"Attribute\"\n"
+ "infoname 2: \"Verification errors\"\n"
+ "infoname 3: \"Debug info\"\n", F);
+}
/**
* dumps the VCG header
*/
void dump_vcg_header(FILE *F, const char *name, const char *layout, const char *orientation)
{
- int i;
const char *label
= (flags & ir_dump_flag_disable_edge_labels) ? "no" : "yes";
- init_colors();
-
if (! layout) layout = "Compilergraph";
if (!orientation) orientation = "bottom_to_top";
"classname 19: \"Postdominators\"\n"
"classname 20: \"Keep Alive\"\n"
"classname 21: \"Out Edges\"\n"
- "classname 22: \"Macro Block Edges\"\n"
- //"classname 23: \"NoInput Nodes\"\n"
- "infoname 1: \"Attribute\"\n"
- "infoname 2: \"Verification errors\"\n"
- "infoname 3: \"Debug info\"\n",
+ "classname 22: \"Macro Block Edges\"\n",
name, label, layout, orientation);
-
- for (i = 0; i < ird_color_count; ++i) {
- if (color_rgb[i] != NULL) {
- fprintf(F, "colorentry %s: %s\n", color_names[i], color_rgb[i]);
- }
- }
+ dump_vcg_infonames(F);
+ dump_vcg_header_colors(F);
fprintf(F, "\n");
}
size_t j, n_blks;
fprintf(F, "graph: { title: \"");
- PRINT_EXTBBID(leader);
+ fprintf(F, "x%ld", get_irn_node_nr(leader));
fprintf(F, "\" label: \"ExtBB %ld\" status:clustered color:lightgreen\n",
get_irn_node_nr(leader));
construct_extblock_lists(irg);
- fprintf(F, "graph: { title: \"");
- PRINT_IRGID(irg);
- fprintf(F, "\" label: \"%s\" status:clustered color: white \n",
+ fprintf(F, "graph: { title: ");
+ print_irgid(F, irg);
+ fprintf(F, " label: \"%s\" status:clustered color: white\n",
get_ent_dump_name(ent));
dump_graph_info(F, irg);
if (is_Block(block)) {
/* This is a block. Dump a node for the block. */
- fprintf(F, "node: {title: \""); PRINT_NODEID(block);
- fprintf(F, "\" label: \"");
+ fprintf(F, "node: {title: ");
+ print_nodeid(F, block);
+ fprintf(F, " label: \"");
if (block == get_irg_start_block(get_irn_irg(block)))
fprintf(F, "Start ");
if (block == get_irg_end_block(get_irn_irg(block)))
fprintf(F, "End ");
fprintf(F, "%s ", get_op_name(get_irn_op(block)));
- PRINT_NODEID(block);
+ print_nodeid(F, block);
fprintf(F, "\" ");
fprintf(F, "info1:\"");
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, "edge: { sourcename: ");
+ print_nodeid(F, block);
+ fprintf(F, " targetname: ");
+ print_nodeid(F, pred);
fprintf(F, "\"}\n");
}
if (ir_get_dump_flags() & ir_dump_flag_dominance) {
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");
+ fprintf(F, "edge: { sourcename: ");
+ print_nodeid(F, block);
+ fprintf(F, " targetname: ");
+ print_nodeid(F, pred);
+ fprintf(F, " " DOMINATOR_EDGE_ATTR "}\n");
}
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: \"");
- PRINT_NODEID(pred);
- fprintf(F, "\" " POSTDOMINATOR_EDGE_ATTR "}\n");
+ fprintf(F, "edge: { sourcename: ");
+ print_nodeid(F, block);
+ fprintf(F, " targetname: ");
+ print_nodeid(F, pred);
+ fprintf(F, " " POSTDOMINATOR_EDGE_ATTR "}\n");
}
}
}
void dump_typegraph(FILE *out)
{
- dump_vcg_header(out, "All_types", "Hierarchic", NULL);
+ dump_vcg_header(out, "All_types", NULL, NULL);
type_walk(dump_type_info, NULL, out);
dump_vcg_footer(out);
}
void dump_class_hierarchy(FILE *out)
{
- dump_vcg_header(out, "class_hierarchy", "Hierarchic", NULL);
+ dump_vcg_header(out, "class_hierarchy", NULL, NULL);
type_walk(dump_class_hierarchy_node, NULL, out);
dump_vcg_footer(out);
}
if (loop_node_started) { /* Close the "firm-nodes" node first if we started one. */
fprintf(F, "\" }\n");
- fprintf(F, "edge: {sourcename: \"");
- PRINT_LOOPID(loop);
- fprintf(F, "\" targetname: \"");
- PRINT_LOOPID(loop);
- fprintf(F, "-%lu-nodes\" label:\"%lu...%lu\"}\n",
+ fprintf(F, "edge: {sourcename: ");
+ print_loopid(F, loop);
+ fprintf(F, " targetname: \"l%ld-%lu-nodes\" label:\"%lu...%lu\"}\n",
+ get_loop_loop_nr(loop),
(unsigned long) first,
(unsigned long) first,
(unsigned long) i-1);
ir_node *n = le.node;
if (!loop_node_started) {
/* Start a new node which contains all firm nodes of the current loop */
- fprintf(F, "node: { title: \"");
- PRINT_LOOPID(loop);
- fprintf(F, "-%lu-nodes\" color: lightyellow label: \"",
+ fprintf(F, "node: { title: \"l%ld-%lu-nodes\" color: lightyellow label: \"",
+ get_loop_loop_nr(loop),
(unsigned long)i);
loop_node_started = true;
first = i;
fprintf(F, "\n");
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 */
ir_graph *n;
n = le.irg;
if (!loop_node_started) {
/* Start a new node which contains all firm nodes of the current loop */
- fprintf(F, "node: { title: \"");
- PRINT_LOOPID(loop);
- fprintf(F, "-%lu-nodes\" color: lightyellow label: \"",
+ fprintf(F, "node: { title: \"l%ld-%lu-nodes\" color: lightyellow label: \"",
+ get_loop_loop_nr(loop),
(unsigned long)i);
loop_node_started = true;
first = i;
if (loop_node_started) {
fprintf(F, "\" }\n");
fprintf(F, "edge: {sourcename: \"");
- PRINT_LOOPID(loop);
- fprintf(F, "\" targetname: \"");
- PRINT_LOOPID(loop);
- fprintf(F, "-%lu-nodes\" label:\"%lu...%lu\"}\n",
+ print_loopid(F, loop);
+ fprintf(F, "\" targetname: \"l%ld-%lu-nodes\" label:\"%lu...%lu\"}\n",
+ get_loop_loop_nr(loop),
(unsigned long) first,
(unsigned long) first,
(unsigned long) i-1);
dump_vcg_footer(out);
}
-static void collect_nodeloop(FILE *F, ir_loop *loop, eset *loopnodes)
+static void collect_nodeloop(FILE *F, ir_loop *loop, pset *loopnodes)
{
size_t i;
int son_number = 0;
} else {
if (flags & ir_dump_flag_loops)
dump_loop_node_edge(F, loop, node_number++);
- eset_insert(loopnodes, le.node);
+ pset_insert_ptr(loopnodes, le.node);
}
}
}
-static void collect_nodeloop_external_nodes(ir_loop *loop, eset *loopnodes,
- eset *extnodes)
+static void collect_nodeloop_external_nodes(ir_loop *loop, pset *loopnodes,
+ pset *extnodes)
{
size_t i;
int j, start;
if (is_Block(le.node)) start = 0; else start = -1;
for (j = start; j < get_irn_arity(le.node); j++) {
ir_node *pred = get_irn_n(le.node, j);
- if (!eset_contains(loopnodes, pred)) {
- eset_insert(extnodes, pred);
+ if (!pset_find_ptr(loopnodes, pred)) {
+ pset_insert_ptr(extnodes, pred);
if (!is_Block(pred)) {
pred = get_nodes_block(pred);
- if (!eset_contains(loopnodes, pred)) eset_insert(extnodes, pred);
+ if (!pset_find_ptr(loopnodes, pred))
+ pset_insert_ptr(extnodes, pred);
}
}
}
void dump_loop(FILE *F, ir_loop *l)
{
- eset *loopnodes = eset_create();
- eset *extnodes = eset_create();
+ pset *loopnodes = pset_new_ptr_default();
+ pset *extnodes = pset_new_ptr_default();
ir_node *n, *b;
char name[50];
collect_nodeloop_external_nodes(l, loopnodes, extnodes);
/* build block lists */
- eset_foreach(loopnodes, ir_node*, n) {
+ foreach_pset(loopnodes, ir_node*, n) {
set_irn_link(n, NULL);
}
- eset_foreach(extnodes, ir_node*, n) {
+ foreach_pset(extnodes, ir_node*, n) {
set_irn_link(n, NULL);
}
- eset_foreach(loopnodes, ir_node*, n) {
+ foreach_pset(loopnodes, ir_node*, n) {
if (!is_Block(n)) {
b = get_nodes_block(n);
set_irn_link(n, get_irn_link(b));
set_irn_link(b, n);
}
}
- eset_foreach(extnodes, ir_node*, n) {
+ foreach_pset(extnodes, ir_node*, n) {
if (!is_Block(n)) {
b = get_nodes_block(n);
set_irn_link(n, get_irn_link(b));
}
}
- eset_foreach(loopnodes, ir_node*, b) {
+ foreach_pset(loopnodes, ir_node*, b) {
if (is_Block(b)) {
- fprintf(F, "graph: { title: \"");
- PRINT_NODEID(b);
- fprintf(F, "\" label: \"");
+ fprintf(F, "graph: { title: ");
+ print_nodeid(F, b);
+ fprintf(F, " label: \"");
dump_node_opcode(F, b);
fprintf(F, " %ld:%u", get_irn_node_nr(b), get_irn_idx(b));
fprintf(F, "\" status:clustered color:yellow\n");
/* dump the nodes that go into the block */
for (n = (ir_node*)get_irn_link(b); n; n = (ir_node*)get_irn_link(n)) {
- if (eset_contains(extnodes, n))
+ if (pset_find_ptr(extnodes, n))
overrule_nodecolor = ird_color_block_inout;
dump_node(F, n);
overrule_nodecolor = ird_color_default_node;
- if (!eset_contains(extnodes, n)) dump_ir_data_edges(F, n);
+ if (!pset_find_ptr(extnodes, n)) dump_ir_data_edges(F, n);
}
/* Close the vcg information for the block */
fprintf(F, "\n");
}
}
- eset_foreach(extnodes, ir_node*, b) {
+ foreach_pset(extnodes, ir_node*, b) {
if (is_Block(b)) {
- fprintf(F, "graph: { title: \"");
- PRINT_NODEID(b);
- fprintf(F, "\" label: \"");
+ fprintf(F, "graph: { title: ");
+ print_nodeid(F, b);
+ fprintf(F, " label: \"");
dump_node_opcode(F, 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 */
for (n = (ir_node*)get_irn_link(b); n; n = (ir_node*)get_irn_link(n)) {
- if (!eset_contains(loopnodes, n))
+ if (!pset_find_ptr(loopnodes, n))
overrule_nodecolor = ird_color_block_inout;
dump_node(F, n);
overrule_nodecolor = ird_color_default_node;
- if (eset_contains(loopnodes, n)) dump_ir_data_edges(F, n);
+ if (pset_find_ptr(loopnodes, n)) dump_ir_data_edges(F, n);
}
/* Close the vcg information for the block */
fprintf(F, "\n");
}
}
- eset_destroy(loopnodes);
- eset_destroy(extnodes);
+ del_pset(loopnodes);
+ del_pset(extnodes);
dump_vcg_footer(F);
}
obstack_1grow(&obst, '\0');
file_name = (char*)obstack_finish(&obst);
- /* xvcg expects only <CR> so we need "b"inary mode (for win32) */
+ /* xvcg expects only <LF> so we need "b"inary mode (for win32) */
out = fopen(file_name, "wb");
obstack_free(&obst, file_name);
projects / libfirm / blobdiff