#include <errno.h>
#include "list.h"
+#include "pset.h"
#include "irnode_t.h"
#include "irgraph_t.h"
#include "irdom.h"
#include "irloop_t.h"
#include "callgraph.h"
-#include "irextbb_t.h"
#include "irhooks.h"
#include "dbginfo_t.h"
#include "irtools.h"
#include "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, "\"");
- ir_vfprintf(F, fmt, ap);
- fprintf(F,"}\n");
- va_end(ap);
-}
-
-/**
- * Prints the edge from an entity ent to a node irn with additional info fmt, ...
- * to the file F.
- */
-static void print_ent_node_edge(FILE *F, const ir_entity *ent, const ir_node *irn, const char *fmt, ...)
-{
- 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_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_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);
*/
static void *ird_get_irn_link(const ir_node *n)
{
- void *res = NULL;
if (irdump_link_map == NULL)
return NULL;
- if (pmap_contains(irdump_link_map, n))
- res = pmap_get(irdump_link_map, n);
- return res;
+ return pmap_get(void, irdump_link_map, n);
}
/**
*/
static void *ird_get_irg_link(const ir_graph *irg)
{
- void *res = NULL;
if (irdump_link_map == NULL)
return NULL;
- if (pmap_contains(irdump_link_map, irg))
- res = pmap_get(irdump_link_map, irg);
- return res;
+ return pmap_get(void, irdump_link_map, irg);
}
/**
* 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);
}
-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);
- 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);
-
- inc_irg_block_visited(irg);
- for (i = 0, n = ARR_LEN(blk_list); i < n; ++i) {
- ir_extblk *ext;
-
- if (is_Block(blk_list[i])) {
- ext = get_Block_extbb(blk_list[i]);
-
- if (extbb_not_visited(ext)) {
- ARR_APP1(ir_extblk *, lists->extbb_list, ext);
- mark_extbb_visited(ext);
- }
- } else
- ARR_APP1(ir_node *, lists->blk_list, blk_list[i]);
- }
- DEL_ARR_F(blk_list);
-
- current_ir_graph = rem;
- ird_set_irg_link(irg, lists);
- return lists;
-}
-
void dump_node_opcode(FILE *F, const ir_node *n)
{
const ir_op_ops *ops = get_op_ops(get_irn_op(n));
fprintf(F, "%s%s", get_irn_opname(n),
(flags & ir_dump_flag_show_marks) ? (get_Block_mark(n) ? "*" : "") : "");
break;
- case iro_Conv:
- if (get_Conv_strict(n))
- fprintf(F, "strict");
- fprintf(F, "%s", get_irn_opname(n));
- break;
case iro_Div:
fprintf(F, "%s", get_irn_opname(n));
if (get_Div_no_remainder(n))
*/
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");
}
}
}
* 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))
+ if (get_nodes_block(from) == get_nodes_block(get_irn_n(from, to)))
fprintf(F, INTRA_DATA_EDGE_ATTR);
else
fprintf(F, INTER_DATA_EDGE_ATTR);
* 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))
+ if (get_nodes_block(from) == get_nodes_block(get_irn_n(from, to)))
fprintf(F, INTRA_MEM_EDGE_ATTR);
else
fprintf(F, INTER_MEM_EDGE_ATTR);
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);
*/
static void dump_ir_edges(ir_node *node, void *env)
{
- int i = 0;
- FILE *F = (FILE*)env;
- const ir_edge_t *edge;
+ int i = 0;
+ FILE *F = (FILE*)env;
foreach_out_edge(node, edge) {
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))
+ && irg_has_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_LOOPINFO))
dump_loop_nodes_into_graph(F, irg);
-
- current_ir_graph = rem;
}
/**
fprintf(F, "\n");
/* dump graph state */
- fprintf(F, "state:");
- if (is_irg_state(irg, IR_GRAPH_STATE_ARCH_DEP))
+ fprintf(F, "constraints:");
+ if (irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_ARCH_DEP))
fprintf(F, " arch_dep");
- if (is_irg_state(irg, IR_GRAPH_STATE_MODEB_LOWERED))
+ if (irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_MODEB_LOWERED))
fprintf(F, " modeb_lowered");
- if (is_irg_state(irg, IR_GRAPH_STATE_NORMALISATION2))
+ if (irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_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))
+ if (irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_OPTIMIZE_UNREACHABLE_CODE))
fprintf(F, " optimize_unreachable_code");
- if (is_irg_state(irg, IR_GRAPH_STATE_NO_CRITICAL_EDGES))
+ fprintf(F, "\n");
+
+ fprintf(F, "properties:");
+ if (irg_has_properties(irg, IR_GRAPH_PROPERTY_NO_CRITICAL_EDGES))
fprintf(F, " no_critical_edges");
- if (is_irg_state(irg, IR_GRAPH_STATE_NO_BADS))
+ if (irg_has_properties(irg, IR_GRAPH_PROPERTY_NO_BADS))
fprintf(F, " no_bads");
- if (is_irg_state(irg, IR_GRAPH_STATE_NO_UNREACHABLE_CODE))
+ if (irg_has_properties(irg, IR_GRAPH_PROPERTY_NO_UNREACHABLE_CODE))
fprintf(F, " no_unreachable_code");
- if (is_irg_state(irg, IR_GRAPH_STATE_ONE_RETURN))
+ if (irg_has_properties(irg, IR_GRAPH_PROPERTY_ONE_RETURN))
fprintf(F, " one_return");
- if (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_DOMINANCE))
+ if (irg_has_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE))
fprintf(F, " consistent_dominance");
- if (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_POSTDOMINANCE))
+ if (irg_has_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_POSTDOMINANCE))
fprintf(F, " consistent_postdominance");
- if (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_OUT_EDGES))
+ if (irg_has_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_OUT_EDGES))
fprintf(F, " consistent_out_edges");
- if (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_OUTS))
+ if (irg_has_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_OUTS))
fprintf(F, " consistent_outs");
- if (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_LOOPINFO))
+ if (irg_has_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_LOOPINFO))
fprintf(F, " consistent_loopinfo");
- if (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_ENTITY_USAGE))
+ if (irg_has_properties(irg, IR_GRAPH_PROPERTY_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");
}
{
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);
switch (get_kind(tore.ent)) {
case k_entity: {
ir_entity *ent = tore.ent;
- ir_node *value;
/* The node */
dump_entity_node(F, ent);
/* The Edges */
if (ent->initializer != NULL) {
/* new style initializers */
dump_entity_initializer(F, ent);
- } else if (entity_has_compound_ent_values(ent)) {
- /* old style compound entity values */
- for (i = get_compound_ent_n_values(ent); i > 0;) {
- value = get_compound_ent_value(ent, --i);
- if (value) {
- print_ent_node_edge(F, ent, value, ENT_VALUE_EDGE_ATTR, i);
- dump_const_expression(F, value);
- print_ent_ent_edge(F, ent, get_compound_ent_value_member(ent, i), 0, ird_color_none, ENT_CORR_EDGE_ATTR, i);
- /*
- fprintf(F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
- ENT_CORR_EDGE_ATTR "}\n", GET_ENTID(ent),
- get_compound_ent_value_member(ent, i), i);
- */
- }
- }
}
}
break;
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;
}
}
}
}
+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
*/
"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);
+ dump_vcg_infonames(F);
dump_vcg_header_colors(F);
fprintf(F, "\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)
-{
- 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];
- ir_node *leader = get_extbb_leader(extbb);
- size_t j, n_blks;
-
- fprintf(F, "graph: { title: \"");
- PRINT_EXTBBID(leader);
- fprintf(F, "\" label: \"ExtBB %ld\" status:clustered color:lightgreen\n",
- get_irn_node_nr(leader));
-
- for (j = 0, n_blks = ARR_LEN(extbb->blks); j < n_blks; ++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 ((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;
- free_extbb(irg);
-}
-
-static void dump_blocks_extbb_grouped(FILE *F, ir_graph *irg)
-{
- size_t i;
- ir_entity *ent = get_irg_entity(irg);
-
- if (!is_irg_state(irg, IR_GRAPH_STATE_VALID_EXTENDED_BLOCKS))
- compute_extbb(irg);
-
- 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(); i > 0;) {
- 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(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(other_irg, lists->blk_list);
- dump_block_graph(F, other_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");
-
- free_extbb(irg);
-}
-
void dump_ir_graph_file(FILE *out, ir_graph *irg)
{
dump_vcg_header(out, get_irg_dump_name(irg), NULL, NULL);
/* dump nodes */
if (flags & ir_dump_flag_blocks_as_subgraphs) {
- if (flags & ir_dump_flag_group_extbb) {
- dump_blocks_extbb_grouped(out, irg);
- } else {
- dump_blocks_as_subgraphs(out, irg);
- }
+ dump_blocks_as_subgraphs(out, irg);
} else {
/* dump_node_with_edges must be called in post visiting predecessors */
ird_walk_graph(irg, NULL, dump_node_with_edges, out);
/* 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);
}
/* dump the out edges in a separate walk */
if ((flags & ir_dump_flag_out_edges)
- && (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_OUTS))) {
+ && (irg_has_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_OUTS))) {
irg_out_walk(get_irg_start(irg), dump_out_edge, 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");
}
/* Dump dominator/postdominator edge */
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)) {
+ if (irg_has_properties(get_irn_irg(block), IR_GRAPH_PROPERTY_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)) {
+ if (irg_has_properties(get_irn_irg(block), IR_GRAPH_PROPERTY_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();
- ir_node *n, *b;
+ pset *loopnodes = pset_new_ptr_default();
+ pset *extnodes = pset_new_ptr_default();
char name[50];
snprintf(name, sizeof(name), "loop_%ld", get_loop_loop_nr(l));
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);
+ ir_node *const 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);
+ ir_node *const b = get_nodes_block(n);
set_irn_link(n, get_irn_link(b));
set_irn_link(b, n);
}
}
- 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_ir_data_edges(F, b);
/* 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))
+ for (ir_node *n = (ir_node*)get_irn_link(b); n; n = (ir_node*)get_irn_link(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))
+ for (ir_node *n = (ir_node*)get_irn_link(b); n; n = (ir_node*)get_irn_link(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