/*
- * Copyright (C) 1995-2010 University of Karlsruhe. All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved.
*
* This file is part of libFirm.
*
* @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 "irtools.h"
#include "irprintf.h"
-#include "irvrfy.h"
+#include "irverify.h"
#include "error.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;
ir_dump_flag_back_edges |
ir_dump_flag_consts_local |
ir_dump_flag_analysed_types |
- ir_dump_flag_entities_in_hierarchy;
+ ir_dump_flag_entities_in_hierarchy |
+ ir_dump_flag_number_label;
static ird_color_t overrule_nodecolor = ird_color_default_node;
obstack_1grow(&color_obst, '\0');
color_rgb[num] = rgb_def;
- color_names[num] = obstack_finish(&color_obst);
+ color_names[num] = (const char*)obstack_finish(&color_obst);
}
/** Define a named color. */
/** 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);
- vfprintf(F, fmt, ap);
+ 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, "\"");
- vfprintf(F, fmt, ap);
+ 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, "\"");
- vfprintf(F, fmt, ap);
+ 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_t) -1)
+ if (color != ird_color_none)
print_vcg_color(F, color);
fprintf(F, "}\n");
va_end(ap);
va_list ap;
va_start(ap, fmt);
- fprintf(F, "edge: { sourcename: \""); PRINT_ENTID(ent);
- fprintf(F, "\" targetname: "); PRINT_TYPEID(tp);
- vfprintf(F, fmt, ap);
+ 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);
- vfprintf(F, fmt, ap);
+ 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, "\"");
- vfprintf(F, fmt, ap);
+ 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, "\"");
- vfprintf(F, fmt, ap);
+ 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);
}
* Prints the edge from a type tp to an enumeration item item with additional info fmt, ...
* to the file F.
*/
-static void print_enum_item_edge(FILE *F, const ir_type *tp, int item, const char *fmt, ...)
+static void print_enum_item_edge(FILE *F, const ir_type *tp, size_t item, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
- fprintf(F, "edge: { sourcename: "); PRINT_TYPEID(tp);
- fprintf(F, " targetname: \""); PRINT_ITEMID(tp, item); fprintf(F, "\" ");
- vfprintf(F, fmt, ap);
+ 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);
}
/* global and ahead declarations */
/*-----------------------------------------------------------------*/
-static void dump_node_with_edges(ir_node *n, void *env);
static void dump_loop_nodes_into_graph(FILE *F, ir_graph *irg);
/*-----------------------------------------------------------------*/
* 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);
}
/**
}
/**
- * Walker, allocates an array for all blocks and puts it's nodes non-floating
+ * Walker, allocates an array for all blocks and puts their non-floating
* nodes into this array.
*/
static void collect_node(ir_node *node, void *env)
*/
static ir_node **construct_block_lists(ir_graph *irg)
{
- int i;
-#ifdef INTERPROCEDURAL_VIEW
- int rem_view = get_interprocedural_view();
-#endif
+ size_t i;
int walk_flag = ir_resources_reserved(irg) & IR_RESOURCE_IRN_VISITED;
ir_graph *rem = current_ir_graph;
ir_free_resources(irg, IR_RESOURCE_IRN_VISITED);
}
- for (i = get_irp_n_irgs() - 1; i >= 0; --i)
- ird_set_irg_link(get_irp_irg(i), NULL);
+ 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);
-#ifdef INTERPROCEDURAL_VIEW
- /* Collect also EndReg and EndExcept. We do not want to change the walker. */
- set_interprocedural_view(0);
-#endif
-
- set_irg_visited(current_ir_graph, get_irg_visited(current_ir_graph)-1);
- irg_walk(get_irg_end_reg(current_ir_graph), clear_link, collect_node, current_ir_graph);
- set_irg_visited(current_ir_graph, get_irg_visited(current_ir_graph)-1);
- irg_walk(get_irg_end_except(current_ir_graph), clear_link, collect_node, current_ir_graph);
-
-#ifdef INTERPROCEDURAL_VIEW
- set_interprocedural_view(rem_view);
-#endif
-
if (walk_flag) {
ir_reserve_resources(irg, IR_RESOURCE_IRN_VISITED);
}
current_ir_graph = rem;
- return ird_get_irg_link(irg);
+ return (ir_node**)ird_get_irg_link(irg);
}
-typedef struct _list_tuple {
+typedef struct list_tuple {
ir_node **blk_list;
ir_extblk **extbb_list;
} list_tuple;
static list_tuple *construct_extblock_lists(ir_graph *irg)
{
ir_node **blk_list = construct_block_lists(irg);
- int i;
+ size_t i, n;
ir_graph *rem = current_ir_graph;
list_tuple *lists = XMALLOC(list_tuple);
lists->extbb_list = NEW_ARR_F(ir_extblk *, 0);
inc_irg_block_visited(irg);
- for (i = ARR_LEN(blk_list) - 1; i >= 0; --i) {
+ for (i = 0, n = ARR_LEN(blk_list); i < n; ++i) {
ir_extblk *ext;
if (is_Block(blk_list[i])) {
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;
-#ifdef INTERPROCEDURAL_VIEW
- case iro_Filter:
- if (!get_interprocedural_view())
- fprintf(F, "Proj'");
- else
- goto default_case;
- break;
-#endif
-
- 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;
-
-#ifdef INTERPROCEDURAL_VIEW
- case iro_Start:
- case iro_End:
- case iro_EndExcept:
- case iro_EndReg:
- if (get_interprocedural_view()) {
- fprintf(F, "%s %s", get_irn_opname(n), get_ent_dump_name(get_irg_entity(get_irn_irg(n))));
- break;
- } else
- goto default_case;
-#endif
-
- case iro_CallBegin: {
- ir_node *addr = get_CallBegin_ptr(n);
- ir_entity *ent = NULL;
- if (is_Sel(addr))
- ent = get_Sel_entity(addr);
- else if (is_Global(addr))
- ent = get_Global_entity(addr);
- fprintf(F, "%s", get_irn_opname(n));
- if (ent) fprintf(F, " %s", get_entity_name(ent));
- break;
- }
case iro_Load:
- if (get_Load_align(n) == align_non_aligned)
+ if (get_Load_unaligned(n) == align_non_aligned)
fprintf(F, "ua");
fprintf(F, "%s[%s]", get_irn_opname(n), get_mode_name_ex(get_Load_mode(n), NULL));
break;
case iro_Store:
- if (get_Store_align(n) == align_non_aligned)
+ if (get_Store_unaligned(n) == align_non_aligned)
fprintf(F, "ua");
fprintf(F, "%s", get_irn_opname(n));
break;
case iro_Block:
- if (is_Block_dead(n))
- fputs("Dead ", F);
if (n == get_irg_start_block(get_irn_irg(n)))
fputs("Start ", F);
if (n == get_irg_end_block(get_irn_irg(n)))
case iro_Mod:
fprintf(F, "%s[%s]", get_irn_opname(n), get_mode_name_ex(get_Mod_resmode(n), NULL));
break;
- case iro_DivMod:
- fprintf(F, "%s[%s]", get_irn_opname(n), get_mode_name_ex(get_DivMod_resmode(n), NULL));
- break;
case iro_Builtin:
fprintf(F, "%s[%s]", get_irn_opname(n), get_builtin_kind_name(get_Builtin_kind(n)));
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));
- ir_opcode iro;
+ unsigned iro;
ir_mode *mode;
/* call the dump_node operation if available */
/**
* 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 {
- ir_opcode code; /**< the opcode of the Proj predecessor */
- unsigned num_data; /**< number of data entries */
- const pns_lookup_t *data; /**< the data */
-} proj_lookup_t;
-
-/** the lookup table for Proj(Start) names */
-static const pns_lookup_t start_lut[] = {
-#define X(a) { pn_Start_##a, #a }
- X(X_initial_exec),
- X(P_frame_base),
- X(P_tls),
- X(T_args),
-#undef X
-};
-
-/** the lookup table for Proj(Cond) names */
-static const pns_lookup_t cond_lut[] = {
-#define X(a) { pn_Cond_##a, #a }
- X(false),
- X(true)
-#undef X
-};
-
-/** the lookup table for Proj(Call) names */
-static const pns_lookup_t call_lut[] = {
-#define X(a) { pn_Call_##a, #a }
- X(M),
- X(X_regular),
- X(X_except),
- X(T_result),
- X(P_value_res_base)
-#undef X
-};
-
-/** the lookup table for Proj(Quot) names */
-static const pns_lookup_t quot_lut[] = {
-#define X(a) { pn_Quot_##a, #a }
- X(M),
- X(X_regular),
- X(X_except),
- X(res)
-#undef X
-};
-
-/** the lookup table for Proj(DivMod) names */
-static const pns_lookup_t divmod_lut[] = {
-#define X(a) { pn_DivMod_##a, #a }
- X(M),
- X(X_regular),
- X(X_except),
- X(res_div),
- X(res_mod)
-#undef X
-};
-
-/** the lookup table for Proj(Div) names */
-static const pns_lookup_t div_lut[] = {
-#define X(a) { pn_Div_##a, #a }
- X(M),
- X(X_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_Quot, E(quot_lut) },
- { iro_DivMod, E(divmod_lut) },
- { iro_Div, E(div_lut) },
- { iro_Mod, E(mod_lut) },
- { iro_Load, E(load_lut) },
- { iro_Store, E(store_lut) },
- { iro_Alloc, E(alloc_lut) },
- { iro_CopyB, E(copyb_lut) },
- { iro_InstOf, E(instof_lut) },
- { iro_Raise, E(raise_lut) },
- { iro_Bound, E(bound_lut) }
-#undef E
-};
-
/**
* Dump 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;
- ir_opcode code;
+ unsigned code;
long proj_nr;
const ir_op_ops *ops = get_op_ops(get_irn_op(n));
case iro_Proj:
pred = get_Proj_pred(n);
proj_nr = get_Proj_proj(n);
-#ifdef INTERPROCEDURAL_VIEW
-handle_lut:
-#endif
code = get_irn_opcode(pred);
- if (code == iro_Cmp)
- fprintf(F, "%s ", get_pnc_string(get_Proj_proj(n)));
- else if (code == iro_Proj && get_irn_opcode(get_Proj_pred(pred)) == iro_Start)
+ if (code == iro_Proj && get_irn_opcode(get_Proj_pred(pred)) == iro_Start)
fprintf(F, "Arg %ld ", proj_nr);
else if (code == iro_Cond && get_irn_mode(get_Cond_selector(pred)) != mode_b)
fprintf(F, "%ld ", proj_nr);
}
}
break;
- case iro_Filter:
- proj_nr = get_Filter_proj(n);
-#ifdef INTERPROCEDURAL_VIEW
- if (! get_interprocedural_view()) {
- /* it's a Proj' */
- pred = get_Filter_pred(n);
- goto handle_lut;
- } else
-#endif
- fprintf(F, "%ld ", proj_nr);
- break;
case iro_Sel:
fprintf(F, "%s ", get_ent_dump_name(get_Sel_entity(n)));
break;
case iro_Cast:
ir_fprintf(F, "(%+F)", get_Cast_type(n));
break;
+ case iro_Cmp:
+ fprintf(F, "%s ", get_relation_string(get_Cmp_relation(n)));
+ break;
case iro_Confirm:
- fprintf(F, "%s ", get_pnc_string(get_Confirm_cmp(n)));
+ fprintf(F, "%s ", get_relation_string(get_Confirm_relation(n)));
break;
case iro_CopyB:
ir_fprintf(F, "(%+F)", get_CopyB_type(n));
break;
default:
- ;
- } /* end switch */
-}
-
-#include <math.h>
-#include "execution_frequency.h"
-
-static void dump_node_ana_vals(FILE *F, ir_node *n)
-{
- (void) F;
- (void) n;
-#ifdef INTERPROCEDURAL_VIEW
- fprintf(F, " %lf*(%2.0lf + %2.0lf) = %2.0lf ",
- get_irn_exec_freq(n),
- get_irg_method_execution_frequency(get_irn_irg(n)),
- pow(5, get_irg_recursion_depth(get_irn_irg(n))),
- get_irn_exec_freq(n) * (get_irg_method_execution_frequency(get_irn_irg(n)) + pow(5, get_irg_recursion_depth(get_irn_irg(n))))
- );
-#endif
- return;
+ break;
+ }
}
-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);
switch (get_irn_opcode(n)) {
case iro_Start:
- case iro_EndReg:
- case iro_EndExcept:
case iro_End:
print_vcg_color(F, ird_color_anchor);
break;
print_vcg_color(F, ird_color_error);
break;
case iro_Block:
- if (is_Block_dead(n))
- print_vcg_color(F, ird_color_dead_block_background);
- else
- print_vcg_color(F, ird_color_block_background);
+ print_vcg_color(F, ird_color_block_background);
break;
case iro_Phi:
print_vcg_color(F, ird_color_phi);
void *dump_add_node_info_callback(dump_node_info_cb_t *cb, void *data)
{
- hook_entry_t *info = XMALLOC(hook_entry_t);
+ hook_entry_t *info = XMALLOCZ(hook_entry_t);
info->hook._hook_node_info = cb;
info->context = data;
void dump_remove_node_info_callback(void *handle)
{
- hook_entry_t *info = handle;
+ hook_entry_t *info = (hook_entry_t*)handle;
unregister_hook(hook_node_info, info);
xfree(info);
}
/**
* 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;
for (i = 0; i < get_irn_arity(n); i++) {
ir_node *con = get_irn_n(n, i);
- if (is_constlike_node(con) && !irn_visited(con)) {
- mark_irn_visited(con);
+ if (is_constlike_node(con) && !irn_visited_else_mark(con)) {
/* Generate a new name for the node by appending the names of
n and const. */
- fprintf(F, "node: {title: "); PRINT_CONSTID(n, con);
+ 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_vrfy_irg_dump(n, current_ir_graph, &p);
+ 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_no_Block(n)) {
+ if (!is_Block(n)) {
ir_node *block = get_nodes_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
fprintf(F, INTER_MEM_EDGE_ATTR);
}
-/** Print the vcg attributes for the edge from node from to it's to's input */
-static void print_edge_vcgattr(FILE *F, ir_node *from, int to)
+/** Print the vcg attributes for the edge from node "from" to its "to"th input */
+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");
ir_node *pred = get_irn_n(n, i);
assert(pred);
-#ifdef INTERPROCEDURAL_VIEW
- if ((get_interprocedural_view() && get_irn_visited(pred) < get_irn_visited(n)))
- continue; /* pred not dumped */
-#endif
-
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);
fprintf(F, "}\n");
}
-
- if ((flags & ir_dump_flag_macroblock_edges) && is_Block(n)) {
- ir_node *mb = get_Block_MacroBlock(n);
- fprintf(F, "edge: {sourcename: \"");
- PRINT_NODEID(n);
- fprintf(F, "\" targetname: \"");
- PRINT_NODEID(mb);
- fprintf(F, "\" label: \"mb\" " MACROBLOCK_EDGE_ATTR);
- fprintf(F, "}\n");
- }
}
/**
static void dump_ir_edges(ir_node *node, void *env)
{
int i = 0;
- FILE *F = env;
+ FILE *F = (FILE*)env;
const ir_edge_t *edge;
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 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 = env;
dump_node(F, n);
dump_ir_data_edges(F, n);
}
/** Dumps a node and its edges. */
static void dump_node_with_edges(ir_node *n, void *env)
{
- FILE *F = env;
- dump_node_wo_blockedge(n, env);
+ FILE *F = (FILE*)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 */
if (! get_Block_matured(block))
color = ird_color_block_background;
- if (is_Block_dead(block))
- color = ird_color_dead_block_background;
fprintf(F, "\" status:clustered ");
print_vcg_color(F, color);
dump_block_edge_hook(F, block);
/* dump the nodes that go into the block */
- for (node = ird_get_irn_link(block); node; node = ird_get_irn_link(node)) {
+ for (node = (ir_node*)ird_get_irn_link(block); node; node = (ir_node*)ird_get_irn_link(node)) {
dump_node(F, node);
dump_ir_data_edges(F, node);
}
* The outermost nodes: blocks and nodes not op_pin_state_pinned, Bad, Unknown. */
static void dump_block_graph(FILE *F, ir_graph *irg)
{
- int i;
+ size_t i, n;
ir_graph *rem = current_ir_graph;
- ir_node **arr = ird_get_irg_link(irg);
+ ir_node **arr = (ir_node**)ird_get_irg_link(irg);
current_ir_graph = irg;
- for (i = ARR_LEN(arr) - 1; i >= 0; --i) {
- ir_node * node = arr[i];
+ for (i = 0, n = ARR_LEN(arr); i < n; ++i) {
+ ir_node *node = arr[i];
if (is_Block(node)) {
/* Dumps the block and all the nodes in the block, which are to
be found in Block->link. */
dump_ir_edges(node, F);
}
- if ((flags & ir_dump_flag_loops) && (get_irg_loopinfo_state(irg) & loopinfo_valid))
+ if ((flags & ir_dump_flag_loops)
+ && is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_LOOPINFO))
dump_loop_nodes_into_graph(F, irg);
current_ir_graph = rem;
{
fprintf(F, "info1: \"");
dump_entity_to_file(F, get_irg_entity(irg));
+ fprintf(F, "\n");
+
+ /* dump graph state */
+ fprintf(F, "state:");
+ if (is_irg_state(irg, IR_GRAPH_STATE_ARCH_DEP))
+ fprintf(F, " arch_dep");
+ if (is_irg_state(irg, IR_GRAPH_STATE_MODEB_LOWERED))
+ fprintf(F, " modeb_lowered");
+ if (is_irg_state(irg, IR_GRAPH_STATE_NORMALISATION2))
+ fprintf(F, " normalisation2");
+ if (is_irg_state(irg, IR_GRAPH_STATE_IMPLICIT_BITFIELD_MASKING))
+ fprintf(F, " implicit_bitfield_masking");
+ if (is_irg_state(irg, IR_GRAPH_STATE_OPTIMIZE_UNREACHABLE_CODE))
+ fprintf(F, " optimize_unreachable_code");
+ if (is_irg_state(irg, IR_GRAPH_STATE_NO_CRITICAL_EDGES))
+ fprintf(F, " no_critical_edges");
+ if (is_irg_state(irg, IR_GRAPH_STATE_NO_BADS))
+ fprintf(F, " no_bads");
+ if (is_irg_state(irg, IR_GRAPH_STATE_NO_UNREACHABLE_CODE))
+ fprintf(F, " no_unreachable_code");
+ if (is_irg_state(irg, IR_GRAPH_STATE_ONE_RETURN))
+ fprintf(F, " one_return");
+ if (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_DOMINANCE))
+ fprintf(F, " consistent_dominance");
+ if (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_POSTDOMINANCE))
+ fprintf(F, " consistent_postdominance");
+ if (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_OUT_EDGES))
+ fprintf(F, " consistent_out_edges");
+ if (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_OUTS))
+ fprintf(F, " consistent_outs");
+ if (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_LOOPINFO))
+ fprintf(F, " consistent_loopinfo");
+ if (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_ENTITY_USAGE))
+ fprintf(F, " consistent_entity_usage");
+ if (is_irg_state(irg, IR_GRAPH_STATE_VALID_EXTENDED_BLOCKS))
+ fprintf(F, " valid_exended_blocks");
fprintf(F, "\"\n");
}
{
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);
/** dumps the edges between nodes and their type or entity attributes. */
static void dump_node2type_edges(ir_node *n, void *env)
{
- FILE *F = env;
+ FILE *F = (FILE*)env;
assert(n);
switch (get_irn_opcode(n)) {
}
}
-#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);
- fprintf(F, " label: \"%s ", get_type_tpop_name(tp));
+ print_typeid(F, tp);
+ fprintf(F, " label: \"");
if (tp->dbi != NULL) {
- char buf[256];
+ char buf[1024];
ir_print_type(buf, sizeof(buf), tp);
- fprintf(F, "'%s'", buf);
+ fprintf(F, "%s '%s'", get_type_tpop_name(tp), buf);
} else {
ir_fprintf(F, "%+F", tp);
}
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));
fprintf(F, "}\n");
}
-static void dump_enum_item(FILE *F, ir_type *tp, int pos)
+static void dump_enum_item(FILE *F, ir_type *tp, size_t pos)
{
char buf[1024];
ir_enum_const *ec = get_enumeration_const(tp, pos);
ident *id = get_enumeration_const_nameid(ec);
- tarval *tv = get_enumeration_value(ec);
+ ir_tarval *tv = get_enumeration_value(ec);
if (tv)
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);
(void) ent;
}
-/** Dumps a type or entity and it's edges. */
+/**
+ * type-walker: Dumps a type or entity and its edges.
+ */
static void dump_type_info(type_or_ent tore, void *env)
{
- FILE *F = env;
- int i = 0; /* to shutup gcc */
+ FILE *F = (FILE*)env;
+ size_t i = 0; /* to shutup gcc */
/* dump this type or entity */
ENT_OWN_EDGE_ATTR "}\n", ent, get_entity_owner(ent));*/
print_ent_type_edge(F,ent, get_entity_type(ent), ENT_TYPE_EDGE_ATTR);
if (is_Class_type(get_entity_owner(ent))) {
- for (i = get_entity_n_overwrites(ent) - 1; i >= 0; --i)
- print_ent_ent_edge(F,ent, get_entity_overwrites(ent, i), 0, -1, ENT_OVERWRITES_EDGE_ATTR);
+ for (i = get_entity_n_overwrites(ent); i > 0;)
+ print_ent_ent_edge(F, ent, get_entity_overwrites(ent, --i), 0, ird_color_none, ENT_OVERWRITES_EDGE_ATTR);
}
/* attached subgraphs */
if (! (flags & ir_dump_flag_no_entity_values)) {
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) - 1; i >= 0; --i) {
- value = get_compound_ent_value(ent, i);
+ 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, -1, ENT_CORR_EDGE_ATTR, i);
+ 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),
/* and now the edges */
switch (get_type_tpop_code(tp)) {
case tpo_class:
- for (i = get_class_n_supertypes(tp) - 1; i >= 0; --i)
+ for (i = get_class_n_supertypes(tp); i > 0;) {
+ --i;
print_type_type_edge(F, tp, get_class_supertype(tp, i), TYPE_SUPER_EDGE_ATTR);
- for (i = get_class_n_members(tp) - 1; i >= 0; --i)
+ }
+ for (i = get_class_n_members(tp); i > 0;) {
+ --i;
print_type_ent_edge(F, tp, get_class_member(tp, i), TYPE_MEMBER_EDGE_ATTR);
+ }
break;
case tpo_struct:
- for (i = get_struct_n_members(tp) - 1; i >= 0; --i)
+ for (i = get_struct_n_members(tp); i > 0;) {
+ --i;
print_type_ent_edge(F, tp, get_struct_member(tp, i), TYPE_MEMBER_EDGE_ATTR);
+ }
break;
case tpo_method:
- for (i = get_method_n_params(tp) - 1; i >= 0; --i)
+ for (i = get_method_n_params(tp); i > 0;) {
+ --i;
print_type_type_edge(F, tp, get_method_param_type(tp, i), METH_PAR_EDGE_ATTR,i);
- for (i = get_method_n_ress(tp) - 1; i >= 0; --i)
+ }
+ for (i = get_method_n_ress(tp); i > 0;) {
+ --i;
print_type_type_edge(F, tp, get_method_res_type(tp, i), METH_RES_EDGE_ATTR,i);
+ }
break;
case tpo_union:
- for (i = get_union_n_members(tp) - 1; i >= 0; --i)
+ for (i = get_union_n_members(tp); i > 0;) {
+ --i;
print_type_ent_edge(F, tp, get_union_member(tp, i), UNION_EDGE_ATTR);
+ }
break;
case tpo_array:
print_type_type_edge(F, tp, get_array_element_type(tp), ARR_ELT_TYPE_EDGE_ATTR);
print_type_ent_edge(F, tp, get_array_element_entity(tp), ARR_ENT_EDGE_ATTR);
- for (i = get_array_n_dimensions(tp) - 1; i >= 0; --i) {
- ir_node *upper = get_array_upper_bound(tp, i);
- ir_node *lower = get_array_lower_bound(tp, i);
- print_node_type_edge(F, upper, tp, "label: \"upper %d\"", get_array_order(tp, i));
- print_node_type_edge(F, lower, tp, "label: \"lower %d\"", get_array_order(tp, i));
+ for (i = get_array_n_dimensions(tp); i > 0;) {
+ ir_node *upper, *lower;
+
+ --i;
+ upper = get_array_upper_bound(tp, i);
+ lower = get_array_lower_bound(tp, i);
+ print_node_type_edge(F, upper, tp, "label: \"upper %zu\"", get_array_order(tp, i));
+ print_node_type_edge(F, lower, tp, "label: \"lower %zu\"", get_array_order(tp, i));
dump_const_expression(F, upper);
dump_const_expression(F, lower);
}
break;
case tpo_enumeration:
- for (i = get_enumeration_n_enums(tp) - 1; i >= 0; --i) {
+ for (i = get_enumeration_n_enums(tp); i > 0;) {
+ --i;
dump_enum_item(F, tp, i);
- print_enum_item_edge(F, tp, i, "label: \"item %d\"", i);
+ print_enum_item_edge(F, tp, i, "label: \"item %zu\"", 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;
- } /* 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.
*/
static void dump_class_hierarchy_node(type_or_ent tore, void *ctx)
{
- FILE *F = ctx;
- int i = 0; /* to shutup gcc */
+ FILE *F = (FILE*)ctx;
+ size_t i = 0; /* to shutup gcc */
/* dump this type or entity */
switch (get_kind(tore.ent)) {
dump_entity_node(F, ent);
/* The edges */
print_type_ent_edge(F, get_entity_owner(ent), ent, TYPE_MEMBER_EDGE_ATTR);
- for (i = get_entity_n_overwrites(ent) - 1; i >= 0; --i)
- print_ent_ent_edge(F, get_entity_overwrites(ent, i), ent, 0, -1, ENT_OVERWRITES_EDGE_ATTR);
+ for (i = get_entity_n_overwrites(ent); i > 0;) {
+ --i;
+ print_ent_ent_edge(F, get_entity_overwrites(ent, i), ent, 0, ird_color_none, ENT_OVERWRITES_EDGE_ATTR);
+ }
}
break;
}
case tpo_class:
dump_type_node(F, tp);
/* and now the edges */
- for (i = get_class_n_supertypes(tp) - 1; i >= 0; --i) {
+ for (i = get_class_n_supertypes(tp); i > 0;) {
+ --i;
print_type_type_edge(F,tp,get_class_supertype(tp, i),TYPE_SUPER_EDGE_ATTR);
}
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 */
+ }
}
/*******************************************************************/
/* dump out edges */
static void dump_out_edge(ir_node *n, void *env)
{
- FILE *F = env;
+ FILE *F = (FILE*)env;
int i;
for (i = get_irn_n_outs(n) - 1; i >= 0; --i) {
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 %d, %d sons, %d nodes",
- get_loop_depth(loop), get_loop_n_sons(loop), 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: %d", get_loop_loop_nr(loop));
-#ifdef DEBUG_libfirm /* GL @@@ debug analyses */
- fprintf(F, "\n The loop was analyzed %d times.", PTR_TO_INT(get_loop_link(loop)));
+ fprintf(F, " loop nr: %ld", get_loop_loop_nr(loop));
+#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, "node: {title: \"");
- PRINT_LOOPID(loop);
- fprintf(F, "\" label: \"");
+ 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(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, int 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, int 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));
- fprintf(F, "\" color: darkgreen label: \"%d\"}\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)
{
- int i;
+ 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) - 1; i >= 0; --i) {
+ 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) - 1; 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");
}
static void dump_blocks_as_subgraphs(FILE *out, ir_graph *irg)
{
- int i;
+ size_t i;
construct_block_lists(irg);
* only the requested irg but also all irgs that can be reached
* from irg.
*/
- for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
- ir_graph *irg = get_irp_irg(i);
- ir_node **arr = ird_get_irg_link(irg);
+ for (i = get_irp_n_irgs(); i > 0;) {
+ ir_graph *other_irg = get_irp_irg(--i);
+ ir_node **arr = (ir_node**)ird_get_irg_link(other_irg);
if (arr == NULL)
continue;
- dump_graph_from_list(out, irg);
+ dump_graph_from_list(out, other_irg);
DEL_ARR_F(arr);
}
}
* The outermost nodes: blocks and nodes not op_pin_state_pinned, Bad, Unknown. */
static void dump_extblock_graph(FILE *F, ir_graph *irg)
{
- int i;
+ size_t i, arr_len;
ir_graph *rem = current_ir_graph;
- ir_extblk **arr = ird_get_irg_link(irg);
+ ir_extblk **arr = (ir_extblk**)ird_get_irg_link(irg);
current_ir_graph = irg;
- for (i = ARR_LEN(arr) - 1; i >= 0; --i) {
+ for (i = 0, arr_len = ARR_LEN(arr); i < arr_len; ++i) {
ir_extblk *extbb = arr[i];
ir_node *leader = get_extbb_leader(extbb);
- int j;
+ 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));
- for (j = ARR_LEN(extbb->blks) - 1; j >= 0; --j) {
- ir_node * node = extbb->blks[j];
+ 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. */
}
if ((flags & ir_dump_flag_loops)
- && (get_irg_loopinfo_state(irg) & loopinfo_valid))
+ && (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_LOOPINFO)))
dump_loop_nodes_into_graph(F, irg);
current_ir_graph = rem;
static void dump_blocks_extbb_grouped(FILE *F, ir_graph *irg)
{
- int i;
+ size_t i;
ir_entity *ent = get_irg_entity(irg);
- if (get_irg_extblk_state(irg) != extblk_valid)
+ 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",
+ 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);
print_dbg_info(F, get_entity_dbg_info(ent));
- for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
- ir_graph *irg = get_irp_irg(i);
- list_tuple *lists = ird_get_irg_link(irg);
+ 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(irg, lists->extbb_list);
- dump_extblock_graph(F, irg);
+ ird_set_irg_link(other_irg, lists->extbb_list);
+ dump_extblock_graph(F, other_irg);
}
/* we may have blocks without extended blocks, bad for instance */
if (ARR_LEN(lists->blk_list)) {
- ird_set_irg_link(irg, lists->blk_list);
- dump_block_graph(F, irg);
+ ird_set_irg_link(other_irg, lists->blk_list);
+ dump_block_graph(F, other_irg);
}
DEL_ARR_F(lists->extbb_list);
/* dump the out edges in a separate walk */
if ((flags & ir_dump_flag_out_edges)
- && (get_irg_outs_state(irg) != outs_none)) {
+ && (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_OUTS))) {
irg_out_walk(get_irg_start(irg), dump_out_edge, NULL, out);
}
static void dump_block_to_cfg(ir_node *block, void *env)
{
- FILE *F = env;
- int i, fl = 0;
- ir_node *pred;
+ FILE *F = (FILE*)env;
+ int i;
+
+ if (is_Bad(block) && get_irn_mode(block) == mode_X) {
+ dump_node(F, block);
+ }
if (is_Block(block)) {
/* This is a block. Dump a node for the block. */
- 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:\"");
/* the generic version. */
dump_irnode_to_file(F, block);
- /* Check whether we have bad predecessors to color the block. */
- for (i = get_Block_n_cfgpreds(block) - 1; i >= 0; --i)
- if ((fl = is_Bad(get_Block_cfgpred(block, i))))
- break;
-
fprintf(F, "\""); /* closing quote of info */
if ((block == get_irg_start_block(get_irn_irg(block))) ||
(block == get_irg_end_block(get_irn_irg(block))) )
fprintf(F, " color:blue ");
- else if (fl)
- fprintf(F, " color:yellow ");
fprintf(F, "}\n");
+
/* Dump the edges */
- for (i = get_Block_n_cfgpreds(block) - 1; i >= 0; --i)
- if (!is_Bad(skip_Proj(get_Block_cfgpred(block, i)))) {
- pred = get_nodes_block(skip_Proj(get_Block_cfgpred(block, i)));
- fprintf(F, "edge: { sourcename: \"");
- PRINT_NODEID(block);
- fprintf(F, "\" targetname: \"");
- PRINT_NODEID(pred);
- fprintf(F, "\"}\n");
- }
+ for (i = get_Block_n_cfgpreds(block) - 1; i >= 0; --i) {
+ ir_node *pred = get_Block_cfgpred(block, i);
+ if (!is_Bad(pred))
+ pred = get_nodes_block(pred);
+ fprintf(F, "edge: { sourcename: ");
+ print_nodeid(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 (get_irg_dom_state(current_ir_graph) == dom_consistent && get_Block_idom(block)) {
- pred = get_Block_idom(block);
- fprintf(F, "edge: { sourcename: \"");
- PRINT_NODEID(block);
- fprintf(F, "\" targetname: \"");
- PRINT_NODEID(pred);
- fprintf(F, "\" " DOMINATOR_EDGE_ATTR "}\n");
+ if (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(F, block);
+ fprintf(F, " targetname: ");
+ print_nodeid(F, pred);
+ fprintf(F, " " DOMINATOR_EDGE_ATTR "}\n");
}
- if (get_irg_postdom_state(current_ir_graph) == dom_consistent && get_Block_ipostdom(block)) {
- pred = get_Block_ipostdom(block);
- fprintf(F, "edge: { sourcename: \"");
- PRINT_NODEID(block);
- fprintf(F, "\" targetname: \"");
- PRINT_NODEID(pred);
- fprintf(F, "\" " POSTDOMINATOR_EDGE_ATTR "}\n");
+ 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(F, block);
+ fprintf(F, " targetname: ");
+ print_nodeid(F, pred);
+ fprintf(F, " " POSTDOMINATOR_EDGE_ATTR "}\n");
}
}
}
void dump_cfg(FILE *F, ir_graph *irg)
{
-#ifdef INTERPROCEDURAL_VIEW
- int ipv = get_interprocedural_view();
-#endif
-
dump_vcg_header(F, get_irg_dump_name(irg), NULL, NULL);
-#ifdef INTERPROCEDURAL_VIEW
- if (ipv) {
- printf("Warning: dumping cfg not in interprocedural view!\n");
- set_interprocedural_view(0);
- }
-#endif
-
/* walk over the blocks in the graph */
- irg_block_walk(get_irg_end(irg), dump_block_to_cfg, NULL, F);
- dump_node(F, get_irg_bad(irg));
+ irg_walk_graph(irg, dump_block_to_cfg, NULL, F);
-#ifdef INTERPROCEDURAL_VIEW
- set_interprocedural_view(ipv);
-#endif
dump_vcg_footer(F);
}
void dump_callgraph(FILE *F)
{
- int i;
+ size_t i;
ir_dump_flags_t old_flags = ir_get_dump_flags();
ir_remove_dump_flags(ir_dump_flag_disable_edge_labels);
dump_vcg_header(F, "Callgraph", "Hierarchic", NULL);
- for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
- ir_graph *irg = get_irp_irg(i);
+ for (i = get_irp_n_irgs(); i > 0;) {
+ ir_graph *irg = get_irp_irg(--i);
ir_entity *ent = get_irg_entity(irg);
- int j;
- int n_callees = get_irg_n_callees(irg);
+ size_t j, n_callees = get_irg_n_callees(irg);
dump_entity_node(F, ent);
for (j = 0; j < n_callees; ++j) {
ir_entity *c = get_irg_entity(get_irg_callee(irg, j));
int be = is_irg_callee_backedge(irg, j);
const char *attr = be
- ? "label:\"recursion %d\""
- : "label:\"calls %d\"";
+ ? "label:\"recursion %zu\""
+ : "label:\"calls %zu\"";
print_ent_ent_edge(F, ent, c, be, ird_color_entity, attr,
get_irg_callee_loop_depth(irg, j));
}
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);
}
static void dump_loops_standalone(FILE *F, ir_loop *loop)
{
- int i = 0, loop_node_started = 0, son_number = 0, first = 0;
+ size_t i;
+ bool loop_node_started = false;
+ size_t first = 0;
+ size_t son_number = 0;
loop_element le;
ir_loop *son = NULL;
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, "-%d-nodes\" label:\"%d...%d\"}\n", first, first, i-1);
- loop_node_started = 0;
+ 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);
+ loop_node_started = false;
}
dump_loop_son_edge(F, loop, son_number++);
dump_loops_standalone(F, son);
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, "-%d-nodes\" color: lightyellow label: \"", i);
- loop_node_started = 1;
+ 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;
} else
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, "-%d-nodes\" color: lightyellow label: \"", i);
- loop_node_started = 1;
+ 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;
} else
fprintf(F, "\n");
if (loop_node_started) {
fprintf(F, "\" }\n");
fprintf(F, "edge: {sourcename: \"");
- PRINT_LOOPID(loop);
- fprintf(F, "\" targetname: \"");
- PRINT_LOOPID(loop);
- fprintf(F, "-%d-nodes\" label:\"%d...%d\"}\n", first, first, i-1);
- loop_node_started = 0;
+ 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);
+ loop_node_started = false;
}
}
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)
{
- int i, son_number = 0, node_number = 0;
+ size_t i;
+ int son_number = 0;
+ int node_number = 0;
if (flags & ir_dump_flag_loops)
dump_loop_node(F, loop);
} 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)
{
- int i, j, start;
+ size_t i;
+ int j, start;
for (i = 0; i < get_loop_n_elements(loop); i++) {
loop_element le = get_loop_element(loop, i);
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];
- snprintf(name, sizeof(name), "loop_%d", get_loop_loop_nr(l));
+ snprintf(name, sizeof(name), "loop_%ld", get_loop_loop_nr(l));
dump_vcg_header(F, name, NULL, NULL);
/* collect all nodes to dump */
collect_nodeloop_external_nodes(l, loopnodes, extnodes);
/* build block lists */
- for (n = eset_first(loopnodes); n != NULL; n = eset_next(loopnodes))
+ foreach_pset(loopnodes, ir_node*, n) {
set_irn_link(n, NULL);
- for (n = eset_first(extnodes); n != NULL; n = eset_next(extnodes))
+ }
+ foreach_pset(extnodes, ir_node*, n) {
set_irn_link(n, NULL);
- for (n = eset_first(loopnodes); n != NULL; n = eset_next(loopnodes)) {
+ }
+ 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);
}
}
- for (n = eset_first(extnodes); n != NULL; n = eset_next(extnodes)) {
+ foreach_pset(extnodes, ir_node*, n) {
if (!is_Block(n)) {
b = get_nodes_block(n);
set_irn_link(n, get_irn_link(b));
}
}
- for (b = eset_first(loopnodes); b != NULL; b = eset_next(loopnodes)) {
+ 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:%d", get_irn_node_nr(b), get_irn_idx(b));
+ fprintf(F, " %ld:%u", get_irn_node_nr(b), get_irn_idx(b));
fprintf(F, "\" status:clustered color:yellow\n");
/* dump the blocks edges */
dump_ir_data_edges(F, b);
/* dump the nodes that go into the block */
- for (n = get_irn_link(b); n; n = get_irn_link(n)) {
- if (eset_contains(extnodes, n))
+ for (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");
}
}
- for (b = eset_first(extnodes); b != NULL; b = eset_next(extnodes)) {
+ 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:%d", get_irn_node_nr(b), get_irn_idx(b));
+ fprintf(F, " %ld:%u", get_irn_node_nr(b), get_irn_idx(b));
fprintf(F, "\" status:clustered color:lightblue\n");
/* dump the nodes that go into the block */
- for (n = get_irn_link(b); n; n = get_irn_link(n)) {
- if (!eset_contains(loopnodes, n))
+ for (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 = obstack_finish(&obst);
- /* xvcg expects only <CR> so we need "b"inary mode (for win32) */
+ file_name = (char*)obstack_finish(&obst);
+ /* xvcg expects only <LF> so we need "b"inary mode (for win32) */
out = fopen(file_name, "wb");
obstack_free(&obst, file_name);
}
obstack_1grow(&obst, '\0');
- file_name = obstack_finish(&obst);
+ file_name = (char*)obstack_finish(&obst);
out = fopen(file_name, "wb");
obstack_free(&obst, file_name);
void dump_all_ir_graphs(const char *suffix)
{
- int n_irgs = get_irp_n_irgs();
- int i;
+ size_t i, n_irgs = get_irp_n_irgs();
for (i = 0; i < n_irgs; ++i) {
ir_graph *irg = get_irp_irg(i);
}
}
-struct pass_t {
+typedef struct pass_t {
ir_prog_pass_t pass;
char suffix[1];
-};
+} pass_t;
/**
* Wrapper around dump_all_ir_graphs().
*/
static int dump_all_ir_graphs_wrapper(ir_prog *irp, void *context)
{
- struct pass_t *pass = context;
+ pass_t *pass = (pass_t*)context;
(void)irp;
dump_all_ir_graphs(pass->suffix);
ir_prog_pass_t *dump_all_ir_graph_pass(const char *name, const char *suffix)
{
- size_t len = strlen(suffix);
- struct pass_t *pass = xmalloc(sizeof(*pass) + len);
+ size_t len = strlen(suffix) + 1;
+ pass_t *pass = XMALLOCF(pass_t, suffix, len);
ir_prog_pass_t *res = def_prog_pass_constructor(
&pass->pass, name ? name : "dump_all_graphs", dump_all_ir_graphs_wrapper);
res->dump_irprog = ir_prog_no_dump;
res->verify_irprog = ir_prog_no_verify;
- memcpy(pass->suffix, suffix, len+1);
+ memcpy(pass->suffix, suffix, len);
return res;
}