#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"
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.
*
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);
}
/**
*/
static int node_floats(const ir_node *n)
{
+ ir_graph *irg = get_irn_irg(n);
return ((get_irn_pinned(n) == op_pin_state_floats) &&
- (get_irg_pinned(current_ir_graph) == op_pin_state_floats));
+ (get_irg_pinned(irg) == op_pin_state_floats));
}
/**
{
size_t i;
int walk_flag = ir_resources_reserved(irg) & IR_RESOURCE_IRN_VISITED;
- ir_graph *rem = current_ir_graph;
-
- current_ir_graph = irg;
if (walk_flag) {
ir_free_resources(irg, IR_RESOURCE_IRN_VISITED);
for (i = get_irp_n_irgs(); i > 0;)
ird_set_irg_link(get_irp_irg(--i), NULL);
- ird_walk_graph(current_ir_graph, clear_link, collect_node, current_ir_graph);
+ ird_walk_graph(irg, clear_link, collect_node, irg);
if (walk_flag) {
ir_reserve_resources(irg, IR_RESOURCE_IRN_VISITED);
}
- current_ir_graph = rem;
return (ir_node**)ird_get_irg_link(irg);
}
{
ir_node **blk_list = construct_block_lists(irg);
size_t i, n;
- ir_graph *rem = current_ir_graph;
list_tuple *lists = XMALLOC(list_tuple);
- current_ir_graph = irg;
-
lists->blk_list = NEW_ARR_F(ir_node *, 0);
lists->extbb_list = NEW_ARR_F(ir_extblk *, 0);
}
DEL_ARR_F(blk_list);
- current_ir_graph = rem;
ird_set_irg_link(irg, lists);
return lists;
}
*/
static int dump_node_typeinfo(FILE *F, const ir_node *n)
{
+ ir_graph *irg = get_irn_irg(n);
int bad = 0;
if (ir_get_dump_flags() & ir_dump_flag_analysed_types) {
- if (get_irg_typeinfo_state(current_ir_graph) == ir_typeinfo_consistent ||
- get_irg_typeinfo_state(current_ir_graph) == ir_typeinfo_inconsistent) {
+ if (get_irg_typeinfo_state(irg) == ir_typeinfo_consistent ||
+ get_irg_typeinfo_state(irg) == 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 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, const ir_node *n)
{
+ ir_graph *irg = get_irn_irg(n);
int i;
if (!get_opt_dump_const_local()) return;
for (i = 0; i < get_irn_arity(n); i++) {
ir_node *con = get_irn_n(n, i);
if (is_constlike_node(con)) {
- set_irn_visited(con, get_irg_visited(current_ir_graph) - 1);
+ set_irn_visited(con, get_irg_visited(irg) - 1);
}
}
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 (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");
}
}
{
int bad = 0;
const char *p;
+ ir_graph *irg;
if (get_opt_dump_const_local() && is_constlike_node(n))
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);
+ irg = get_irn_irg(n);
+ bad = ! irn_verify_irg_dump(n, irg, &p);
dump_node_label(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));
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");
}
}
}
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 constant expression as entity initializer, array bound ... */
static void dump_const_expression(FILE *F, ir_node *value)
{
- ir_graph *rem = current_ir_graph;
+ ir_graph *irg = get_const_code_irg();
ir_dump_flags_t old_flags = ir_get_dump_flags();
ir_remove_dump_flags(ir_dump_flag_consts_local);
- 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
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);
+ set_irg_visited(irg, get_irg_visited(irg) -1);
ir_set_dump_flags(old_flags);
- current_ir_graph = rem;
}
/** Dump a block as graph containing its nodes.
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 */
static void dump_block_graph(FILE *F, ir_graph *irg)
{
size_t i, n;
- ir_graph *rem = current_ir_graph;
ir_node **arr = (ir_node**)ird_get_irg_link(irg);
- current_ir_graph = irg;
for (i = 0, n = ARR_LEN(arr); i < n; ++i) {
ir_node *node = arr[i];
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;
}
/**
{
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;
- }
-}
-#endif
-
static void print_typespecific_vcgattr(FILE *F, ir_type *tp)
{
switch (get_type_tpop_code(tp)) {
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;
}
break; /* case k_type */
}
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");
}
}
{
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, "\"");
}
+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);
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_element(loop, i).node);
- 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, const ir_loop *loop, size_t i)
{
assert(loop);
- fprintf(F, "edge: {sourcename: \"");
- PRINT_LOOPID(loop);
- fprintf(F, "\" targetname: \"");
- PRINT_LOOPID(get_loop_element(loop, i).son);
- ir_fprintf(F, "\" color: darkgreen label: \"%zu\"}\n", 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, const ir_loop *loop)
static void dump_loop_nodes_into_graph(FILE *F, ir_graph *irg)
{
ir_loop *loop = get_irg_loop(irg);
-
if (loop != NULL) {
- ir_graph *rem = current_ir_graph;
- current_ir_graph = irg;
-
dump_loops(F, loop);
-
- current_ir_graph = rem;
}
}
static void dump_extblock_graph(FILE *F, ir_graph *irg)
{
size_t i, arr_len;
- ir_graph *rem = current_ir_graph;
ir_extblk **arr = (ir_extblk**)ird_get_irg_link(irg);
- current_ir_graph = irg;
for (i = 0, arr_len = ARR_LEN(arr); i < arr_len; ++i) {
ir_extblk *extbb = arr[i];
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));
&& (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_LOOPINFO)))
dump_loop_nodes_into_graph(F, irg);
- current_ir_graph = rem;
free_extbb(irg);
}
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);
/* dump type info */
if (flags & ir_dump_flag_with_typegraph) {
- ir_graph *rem = current_ir_graph;
- current_ir_graph = irg;
-
type_walk_irg(irg, dump_type_info, NULL, out);
inc_irg_visited(get_const_code_irg());
/* dump edges from graph to type info */
irg_walk(get_irg_end(irg), dump_node2type_edges, NULL, out);
-
- current_ir_graph = rem;
}
/* dump iredges out edges */
- if ((flags & ir_dump_flag_iredges) && edges_activated(current_ir_graph)) {
+ if ((flags & ir_dump_flag_iredges) && edges_activated(irg)) {
irg_walk_edges(get_irg_start_block(irg), dump_ir_edges, NULL, out);
}
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);
void dump_loop_tree(FILE *out, ir_graph *irg)
{
- ir_graph *rem = current_ir_graph;
ir_dump_flags_t old_flags = ir_get_dump_flags();
- current_ir_graph = irg;
ir_remove_dump_flags(ir_dump_flag_disable_edge_labels);
dump_vcg_header(out, get_irg_dump_name(irg), "Tree", "top_to_bottom");
dump_vcg_footer(out);
ir_set_dump_flags(old_flags);
- current_ir_graph = rem;
}
void dump_callgraph_loop_tree(FILE *out)
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