#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"
+/**
+ * Symbolic names for the different dumping colors.
+ */
+typedef enum ird_color_t {
+ ird_color_none = -1,
+ ird_color_prog_background,
+ ird_color_block_background,
+ ird_color_dead_block_background,
+ ird_color_block_inout,
+ ird_color_default_node,
+ ird_color_phi,
+ ird_color_memory,
+ ird_color_controlflow,
+ ird_color_const,
+ ird_color_anchor,
+ ird_color_proj,
+ ird_color_uses_memory,
+ ird_color_error,
+ ird_color_entity,
+ ird_color_count
+} ird_color_t;
+
+/**
+ * Edge kinds.
+ */
+typedef enum {
+ data_edge = 0x01, /**< A data edge between two basic blocks. */
+ block_edge = 0x02, /**< An edge from a node to its basic block. */
+ cf_edge = 0x03, /**< A regularly control flow edge. */
+ exc_cf_edge = 0x04, /**< An exceptional control flow edge. */
+ mem_edge = 0x05, /**< A memory edge. */
+ dominator_edge = 0x06, /**< A dominator edge from a block to its immediate dominator. */
+ node2type_edge = 0x07, /**< An edge from an IR node to a type. */
+
+ ent_type_edge = 0x11, /**< An edge from an entity to its type. */
+ ent_own_edge = 0x12, /**< An edge from an entity to its owner type. */
+ ent_overwrites_edge = 0x13, /**< An edge from an entity to the entity it overwrites. */
+ ent_value_edge = 0x14, /**< An edge from an entity to its value entity. */
+ ent_corr_edge = 0x15, /**< An edge from an entity to the member entity its initializes. */
+
+ meth_par_edge = 0x21, /**< An edge from a method type to one of its parameter types. */
+ meth_res_edge = 0x22, /**< An edge from a method type to one of its result types. */
+ type_super_edge = 0x23, /**< An edge from a class type to its super/basis type. */
+ union_edge = 0x24, /**< An edge from a union type to its member types. */
+ ptr_pts_to_edge = 0x25, /**< An edge from a pointer type to its points-to type. */
+ arr_elt_type_edge = 0x26, /**< An edge from an array type to its element type. */
+ arr_ent_edge = 0x27, /**< An edge from a array type to its element entity. */
+ type_member_edge = 0x28, /**< An edge from a compound type to its member entities. */
+
+ /* additional flags */
+ intra_edge = 0, /**< Intra edge flag: edge do not cross basic block boundaries */
+ inter_edge = 0x40, /**< Inter edge flag: edge cross basic block boundaries */
+ back_edge = 0x80 /**< Backwards edge flag. */
+} edge_kind;
+
+/* Attributes of nodes */
+#define PRINT_DEFAULT_NODE_ATTR
+#define DEFAULT_NODE_ATTR " "
+#define DEFAULT_TYPE_ATTRIBUTE " "
+#define DEFAULT_ENUM_ITEM_ATTRIBUTE " "
+
+/* Attributes of edges between Firm nodes */
+#define INTRA_DATA_EDGE_ATTR "class:1 priority:50"
+#define INTER_DATA_EDGE_ATTR "class:16 priority:10"
+#define BLOCK_EDGE_ATTR "class:2 priority:50 linestyle:dotted"
+#define CF_EDGE_ATTR "class:13 priority:60 color:red"
+#define EXC_CF_EDGE_ATTR "class:18 priority:60 color:blue"
+#define INTRA_MEM_EDGE_ATTR "class:14 priority:50 color:blue"
+#define INTER_MEM_EDGE_ATTR "class:17 priority:10 color:blue"
+#define DOMINATOR_EDGE_ATTR "class:15 color:red"
+#define POSTDOMINATOR_EDGE_ATTR "class:19 color:red linestyle:dotted"
+#define KEEP_ALIVE_EDGE_ATTR "class:20 priority:10 color:purple"
+#define KEEP_ALIVE_CF_EDGE_ATTR "class:20 priority:60 color:purple"
+#define KEEP_ALIVE_DF_EDGE_ATTR "class:20 priority:10 color:purple"
+#define ANCHOR_EDGE_ATTR "class:20 priority:60 color:purple linestyle:dotted"
+#define OUT_EDGE_ATTR "class:21 priority:10 color:gold linestyle:dashed"
+
+#define BACK_EDGE_ATTR "linestyle:dashed "
+
+/* Attributes of edges between Firm nodes and type/entity nodes */
+#define NODE2TYPE_EDGE_ATTR "class:2 priority:2 linestyle:dotted"
+
+/* Attributes of edges in type/entity graphs. */
+#define TYPE_METH_NODE_ATTR "color: lightyellow"
+#define TYPE_CLASS_NODE_ATTR "color: green"
+#define TYPE_DESCRIPTION_NODE_ATTR "color: lightgreen"
+#define ENTITY_NODE_ATTR "color: yellow"
+#define ENUM_ITEM_NODE_ATTR "color: green"
+#define ENT_TYPE_EDGE_ATTR "class: 3 label: \"type\" color: red"
+#define ENT_OWN_EDGE_ATTR "class: 4 label: \"owner\" color: black"
+#define METH_PAR_EDGE_ATTR "class: 5 label: \"param %zu\" color: green"
+#define METH_RES_EDGE_ATTR "class: 6 label: \"res %zu\" color: green"
+#define TYPE_SUPER_EDGE_ATTR "class: 7 label: \"supertype\" color: red"
+#define UNION_EDGE_ATTR "class: 8 label: \"component\" color: blue"
+#define PTR_PTS_TO_EDGE_ATTR "class: 9 label: \"points to\" color:green"
+#define ARR_ELT_TYPE_EDGE_ATTR "class: 10 label: \"arr elt tp\" color:green"
+#define ARR_ENT_EDGE_ATTR "class: 10 label: \"arr ent\" color: green"
+#define ENT_OVERWRITES_EDGE_ATTR "class: 11 label: \"overwrites\" color:red"
+#define ENT_VALUE_EDGE_ATTR "label: \"value %d\""
+#define ENT_CORR_EDGE_ATTR "label: \"value %zu corresponds to \" "
+#define TYPE_MEMBER_EDGE_ATTR "class: 12 label: \"member\" color:blue"
+/* #define CALLGRAPH_EDGE_ATTR "calls" */
+
typedef struct pns_lookup {
long nr; /**< the proj number */
const char *name; /**< the name of the Proj */
/* -------------- some extended helper functions ----------------- */
-const char *get_mode_name_ex(const ir_mode *mode, int *bad)
+char const *get_mode_name_ex(ir_mode const *const mode)
{
if (is_mode(mode))
return get_mode_name(mode);
- if (bad != NULL)
- *bad |= 1;
return "<ERROR>";
}
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_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 *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);
}
/**
*/
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));
case iro_Load:
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));
+ fprintf(F, "%s[%s]", get_irn_opname(n), get_mode_name_ex(get_Load_mode(n)));
break;
case iro_Store:
if (get_Store_unaligned(n) == align_non_aligned)
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))
fprintf(F, "RL");
- fprintf(F, "[%s]", get_mode_name_ex(get_Div_resmode(n), NULL));
+ fprintf(F, "[%s]", get_mode_name_ex(get_Div_resmode(n)));
break;
case iro_Mod:
- fprintf(F, "%s[%s]", get_irn_opname(n), get_mode_name_ex(get_Mod_resmode(n), NULL));
+ fprintf(F, "%s[%s]", get_irn_opname(n), get_mode_name_ex(get_Mod_resmode(n)));
break;
case iro_Builtin:
fprintf(F, "%s[%s]", get_irn_opname(n), get_builtin_kind_name(get_Builtin_kind(n)));
if (mode != NULL && mode != mode_BB && mode != mode_ANY && mode != mode_BAD &&
(mode != mode_T || iro == iro_Proj))
- fprintf(F, "%s", get_mode_name_ex(mode, NULL));
+ fprintf(F, "%s", get_mode_name_ex(mode));
}
}
*/
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, "[] ");
proj_nr = get_Proj_proj(n);
code = get_irn_opcode(pred);
- 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);
- else {
+ } else {
unsigned i, j, f = 0;
for (i = 0; i < ARRAY_SIZE(proj_lut); ++i) {
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);
}
}
{
int bad = 0;
const char *p;
+ ir_graph *irg;
if (get_opt_dump_const_local() && is_constlike_node(n))
return;
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);
fputs("\" ", F);
* 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);
*/
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);
/** 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.
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, " label: \"");
dump_node_label(F, block);
- /* colorize blocks */
- if (! get_Block_matured(block))
- color = ird_color_block_background;
-
fprintf(F, "\" status:clustered ");
+ /* colorize blocks */
+ ird_color_t const color =
+ !get_Block_matured(block) ? ird_color_error :
+ ird_color_block_background;
print_vcg_color(F, color);
fprintf(F, "\n");
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");
}
fprintf(F, "graph: { title: ");
print_irgid(F, irg);
- fprintf(F, " label: \"%s\" status:clustered color:%s \n",
+ 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);
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;
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;
}
}
}
}
-/** 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: \"");
- 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 = 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(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(); 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);
}
/* 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(F, block);
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(F, block);
(unsigned long) first,
(unsigned long) first,
(unsigned long) i-1);
- loop_node_started = false;
}
}
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(F, b);
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(F, 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