* @author Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Hubert Schmidt
* @version $Id$
*/
-#ifdef HAVE_CONFIG_H
#include "config.h"
-#endif
-#ifdef HAVE_STRING_H
#include <string.h>
-#endif
-#ifdef HAVE_STDLIB_H
#include <stdlib.h>
-#endif
#include <stdarg.h>
#include "firm_common_t.h"
#include "eset.h"
#include "pset.h"
-#if DO_HEAPANALYSIS
-extern void dump_irn_chi_term(FILE *FL, ir_node *n);
-extern void dump_irn_state(FILE *FL, ir_node *n);
-extern int get_opt_dump_abstvals(void);
-typedef unsigned long SeqNo;
-extern SeqNo get_Block_seqno(ir_node *n);
-#endif
-
/** Dump only irgs with names that start with this prefix. */
static ident *dump_file_filter_id = NULL;
* returns the name of a mode or ERROR_TXT if mode is NOT a mode object.
* in the later case, sets bad.
*/
-const char *get_mode_name_ex(ir_mode *mode, int *bad) {
+const char *get_mode_name_ex(const ir_mode *mode, int *bad) {
if (is_mode(mode))
return get_mode_name(mode);
*bad |= 1;
* returns the name of a type or <ERROR> if mode is NOT a mode object.
* in the later case, sets bad
*/
-const char *get_type_name_ex(ir_type *tp, int *bad) {
+const char *get_type_name_ex(const ir_type *tp, int *bad) {
if (is_type(tp))
return get_type_name(tp);
*bad |= 1;
static const char *color_rgb[ird_color_count];
static struct obstack color_obst;
+/** define a custom color. */
static void custom_color(int num, const char *rgb_def)
{
assert(num < ird_color_count);
color_names[num] = obstack_finish(&color_obst);
}
+/** Define a named color. */
static void named_color(int num, const char *name)
{
assert(num < ird_color_count);
color_names[num] = name;
}
+/** Initializes the used colors. */
static void init_colors(void)
{
static int initialized = 0;
- if(initialized)
+ if (initialized)
return;
obstack_init(&color_obst);
custom_color(ird_color_phi, "105 255 105");
custom_color(ird_color_anchor, "100 100 255");
named_color(ird_color_error, "red");
+ custom_color(ird_color_entity, "204 204 255");
initialized = 1;
}
* Prints the edge from a type S to a type T with additional info fmt, ...
* to the file F.
*/
-static void print_type_type_edge(FILE *F, ir_type *S, ir_type *T, const char *fmt, ...)
+static void print_type_type_edge(FILE *F, const ir_type *S, const ir_type *T, const char *fmt, ...)
{
va_list ap;
}
/**
- * Prints the edge from a type T to an entity E with additional info fmt, ...
+ * Prints the edge from a type tp to an entity ent with additional info fmt, ...
* to the file F.
*/
-static void print_type_ent_edge(FILE *F, ir_type *T, ir_entity *E, const char *fmt, ...)
+static void print_type_ent_edge(FILE *F, const ir_type *tp, const ir_entity *ent, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
- fprintf(F, "edge: { sourcename: "); PRINT_TYPEID(T);
- fprintf(F, " targetname: \""); PRINT_ENTID(E); fprintf(F, "\"");
+ fprintf(F, "edge: { sourcename: "); PRINT_TYPEID(tp);
+ fprintf(F, " targetname: \""); PRINT_ENTID(ent); fprintf(F, "\"");
vfprintf(F, fmt, ap);
fprintf(F, "}\n");
va_end(ap);
}
/**
- * Prints the edge from an entity E to an entity T with additional info fmt, ...
+ * Prints the edge from an entity ent1 to an entity ent2 with additional info fmt, ...
* to the file F.
*/
-static void print_ent_ent_edge(FILE *F, ir_entity *E, ir_entity *T, int backedge, const char *fmt, ...)
+static void print_ent_ent_edge(FILE *F, const ir_entity *ent1, const ir_entity *ent2, int backedge, ird_color_t color, const char *fmt, ...)
{
va_list ap;
fprintf(F, "backedge: { sourcename: \"");
else
fprintf(F, "edge: { sourcename: \"");
- PRINT_ENTID(E);
- fprintf(F, "\" targetname: \""); PRINT_ENTID(T); fprintf(F, "\"");
+ PRINT_ENTID(ent1);
+ fprintf(F, "\" targetname: \""); PRINT_ENTID(ent2); fprintf(F, "\"");
vfprintf(F, fmt, ap);
+ fprintf(F, " ");
+ if (color != (ird_color_t) -1)
+ print_vcg_color(F, color);
fprintf(F, "}\n");
va_end(ap);
}
/**
- * Prints the edge from an entity E to a type T with additional info fmt, ...
+ * Prints the edge from an entity ent to a type tp with additional info fmt, ...
* to the file F.
*/
-static void print_ent_type_edge(FILE *F, ir_entity *E, ir_type *T, const char *fmt, ...)
+static void print_ent_type_edge(FILE *F, const ir_entity *ent, const ir_type *tp, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
- fprintf(F, "edge: { sourcename: \""); PRINT_ENTID(E);
- fprintf(F, "\" targetname: "); PRINT_TYPEID(T);
+ fprintf(F, "edge: { sourcename: \""); PRINT_ENTID(ent);
+ fprintf(F, "\" targetname: "); PRINT_TYPEID(tp);
vfprintf(F, fmt, ap);
fprintf(F,"}\n");
va_end(ap);
}
/**
- * Prints the edge from a node N to a type T with additional info fmt, ...
+ * Prints the edge from a node irn to a type tp with additional info fmt, ...
* to the file F.
*/
-static void print_node_type_edge(FILE *F, const ir_node *N, ir_type *T, const char *fmt, ...)
+static void print_node_type_edge(FILE *F, const ir_node *irn, ir_type *tp, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
- fprintf(F, "edge: { sourcename: \""); PRINT_NODEID(N);
- fprintf(F, "\" targetname: "); PRINT_TYPEID(T);
+ fprintf(F, "edge: { sourcename: \""); PRINT_NODEID(irn);
+ fprintf(F, "\" targetname: "); PRINT_TYPEID(tp);
vfprintf(F, fmt, ap);
fprintf(F,"}\n");
va_end(ap);
}
/**
- * Prints the edge from a node N to an entity E with additional info fmt, ...
+ * Prints the edge from a node irn to an entity ent with additional info fmt, ...
* to the file F.
*/
-static void print_node_ent_edge(FILE *F, const ir_node *N, ir_entity *E, const char *fmt, ...)
+static void print_node_ent_edge(FILE *F, const ir_node *irn, const ir_entity *ent, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
- fprintf(F, "edge: { sourcename: \""); PRINT_NODEID(N);
- fprintf(F, "\" targetname: \""); PRINT_ENTID(E);
+ fprintf(F, "edge: { sourcename: \""); PRINT_NODEID(irn);
+ fprintf(F, "\" targetname: \""); PRINT_ENTID(ent);
fprintf(F, "\"");
vfprintf(F, fmt, ap);
fprintf(F,"}\n");
}
/**
- * Prints the edge from an entity E to a node N with additional info fmt, ...
+ * 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, ir_entity *E, const ir_node *N, const char *fmt, ...)
+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(E);
- fprintf(F, "\" targetname: \""); PRINT_NODEID(N); fprintf(F, "\"");
+ fprintf(F, "edge: { sourcename: \""); PRINT_ENTID(ent);
+ fprintf(F, "\" targetname: \""); PRINT_NODEID(irn); fprintf(F, "\"");
vfprintf(F, fmt, ap);
fprintf(F,"}\n");
va_end(ap);
}
/**
- * Prints the edge from a type E to an enumeration item item with additional info fmt, ...
+ * 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, ir_type *E, int item, const char *fmt, ...)
+static void print_enum_item_edge(FILE *F, const ir_type *tp, int item, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
- fprintf(F, "edge: { sourcename: "); PRINT_TYPEID(E);
- fprintf(F, " targetname: \""); PRINT_ITEMID(E, item); fprintf(F, "\" ");
+ fprintf(F, "edge: { sourcename: "); PRINT_TYPEID(tp);
+ fprintf(F, " targetname: \""); PRINT_ITEMID(tp, item); fprintf(F, "\" ");
vfprintf(F, fmt, ap);
fprintf(F,"}\n");
va_end(ap);
/*-----------------------------------------------------------------*/
static void dump_whole_node(ir_node *n, void *env);
-static INLINE void dump_loop_nodes_into_graph(FILE *F, ir_graph *irg);
+static inline void dump_loop_nodes_into_graph(FILE *F, ir_graph *irg);
/*-----------------------------------------------------------------*/
/* Helper functions. */
/**
* Returns the private link field.
*/
-static void *ird_get_irn_link(ir_node *n) {
+static void *ird_get_irn_link(const ir_node *n) {
void *res = NULL;
- if (!irdump_link_map) return NULL;
+ if (irdump_link_map == NULL)
+ return NULL;
- if (pmap_contains(irdump_link_map, (void *)n))
- res = pmap_get(irdump_link_map, (void *)n);
+ if (pmap_contains(irdump_link_map, n))
+ res = pmap_get(irdump_link_map, n);
return res;
}
/**
* Sets the private link field.
*/
-static void ird_set_irn_link(ir_node *n, void *x) {
- if (!irdump_link_map)
+static void ird_set_irn_link(const ir_node *n, void *x) {
+ if (irdump_link_map == NULL)
init_irdump();
- pmap_insert(irdump_link_map, (void *)n, x);
+ pmap_insert(irdump_link_map, n, x);
}
/**
* Gets the private link field of an irg.
*/
-static void *ird_get_irg_link(ir_graph *irg) {
+static void *ird_get_irg_link(const ir_graph *irg) {
void *res = NULL;
- if (!irdump_link_map) return NULL;
+ if (irdump_link_map == NULL)
+ return NULL;
- if (pmap_contains(irdump_link_map, (void *)irg))
- res = pmap_get(irdump_link_map, (void *)irg);
+ if (pmap_contains(irdump_link_map, irg))
+ res = pmap_get(irdump_link_map, irg);
return res;
}
/**
* Sets the private link field of an irg.
*/
-static void ird_set_irg_link(ir_graph *irg, void *x) {
- if (!irdump_link_map) init_irdump();
- pmap_insert(irdump_link_map, (void *)irg, x);
+static void ird_set_irg_link(const ir_graph *irg, void *x) {
+ if (irdump_link_map == NULL)
+ init_irdump();
+ pmap_insert(irdump_link_map, irg, x);
}
/**
* Walker, clears the private link field.
*/
-static void clear_link(ir_node * node, void * env) {
+static void clear_link(ir_node *node, void *env) {
(void) env;
ird_set_irn_link(node, NULL);
}
* 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(ir_entity *ent, int dump_ld_name) {
- if (!ent)
+static const char *_get_ent_dump_name(const ir_entity *ent, int dump_ld_name) {
+ if (ent == NULL)
return "<NULL entity>";
if (dump_ld_name) {
/* Don't use get_entity_ld_ident (ent) as it computes the mangled name! */
- if (ent->ld_name) return get_id_str(ent->ld_name);
+ if (ent->ld_name != NULL)
+ return get_id_str(ent->ld_name);
}
return get_id_str(ent->name);
}
* If the entity has a ld_name, returns it if the option dump_ld_name is set,
* else returns the name of the entity.
*/
-const char *get_ent_dump_name(ir_entity *ent) {
+const char *get_ent_dump_name(const ir_entity *ent) {
return _get_ent_dump_name(ent, dump_ld_name);
}
/* Returns the name of an IRG. */
-const char *get_irg_dump_name(ir_graph *irg) {
+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), 1);
}
/**
* Returns non-zero if a node is in floating state.
*/
-static int node_floats(ir_node *n) {
+static int node_floats(const ir_node *n) {
return ((get_irn_pinned(n) == op_pin_state_floats) &&
(get_irg_pinned(current_ir_graph) == op_pin_state_floats));
}
/**
* Walker, allocates an array for all blocks and puts it's nodes non-floating nodes into this array.
*/
-static void collect_node(ir_node * node, void *env) {
+static void collect_node(ir_node *node, void *env) {
(void) env;
if (is_Block(node)
|| node_floats(node)
#ifdef INTERPROCEDURAL_VIEW
int rem_view = get_interprocedural_view();
#endif
- int walk_flag = using_irn_visited(irg);
+ int walk_flag = ir_resources_reserved(irg) & IR_RESOURCE_IRN_VISITED;
ir_graph *rem = current_ir_graph;
current_ir_graph = irg;
- if(walk_flag)
- clear_using_irn_visited(current_ir_graph);
+ if(walk_flag) {
+ 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);
set_interprocedural_view(rem_view);
#endif
- if(walk_flag)
- set_using_irn_visited(current_ir_graph);
+ if (walk_flag) {
+ ir_reserve_resources(irg, IR_RESOURCE_IRN_VISITED);
+ }
current_ir_graph = rem;
return ird_get_irg_link(irg);
ir_node **blk_list = construct_block_lists(irg);
int i;
ir_graph *rem = current_ir_graph;
- list_tuple *lists = xmalloc(sizeof(*lists));
+ list_tuple *lists = XMALLOC(list_tuple);
current_ir_graph = irg;
/* implementation for default nodes */
switch (get_irn_opcode(n)) {
-
- case iro_Const:
- ir_fprintf(F, "%T", get_Const_tarval(n));
- break;
-
case iro_SymConst:
switch (get_SymConst_kind(n)) {
case symconst_addr_name:
case symconst_enum_const:
fprintf(F, "SymC %s enum", get_enumeration_name(get_SymConst_enum(n)));
break;
- case symconst_label:
- fprintf(F, "SymC %lu label", get_SymConst_label(n));
- break;
}
break;
ir_node *pred = get_Proj_pred(n);
if (get_irn_opcode(pred) == iro_Cond
- && get_Proj_proj(n) == get_Cond_defaultProj(pred)
+ && get_Proj_proj(n) == get_Cond_default_proj(pred)
&& get_irn_mode(get_Cond_selector(pred)) != mode_b)
fprintf(F, "defProj");
else
case iro_CallBegin: {
ir_node *addr = get_CallBegin_ptr(n);
ir_entity *ent = NULL;
- if (get_irn_op(addr) == op_Sel)
+ if (is_Sel(addr))
ent = get_Sel_entity(addr);
else if (is_Global(addr))
ent = get_Global_entity(addr);
break;
case iro_Div:
fprintf(F, "%s", get_irn_opname(n));
- if (is_Div_remainderless(n))
+ if (get_Div_no_remainder(n))
fprintf(F, "RL");
fprintf(F, "[%s]", get_mode_name_ex(get_Div_resmode(n), &bad));
break;
case iro_DivMod:
fprintf(F, "%s[%s]", get_irn_opname(n), get_mode_name_ex(get_DivMod_resmode(n), &bad));
break;
+ case iro_Builtin:
+ fprintf(F, "%s[%s]", get_irn_opname(n), get_builtin_kind_name(get_Builtin_kind(n)));
+ break;
default:
default_case:
*/
static int dump_node_mode(FILE *F, ir_node *n)
{
- int bad = 0;
+ int bad = 0;
const ir_op_ops *ops = get_op_ops(get_irn_op(n));
- ir_opcode iro;
+ ir_opcode iro;
+ ir_mode *mode;
/* call the dump_node operation if available */
if (ops->dump_node)
case iro_Jmp:
case iro_NoMem:
break;
- default: {
- ir_mode *mode = get_irn_mode(n);
+ default:
+ mode = get_irn_mode(n);
- if (mode && mode != mode_BB && mode != mode_ANY && mode != mode_BAD &&
+ 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, &bad));
}
- }
-
return bad;
}
X(P_frame_base),
X(P_tls),
X(T_args),
- X(P_value_arg_base)
#undef X
};
}
break;
+ case iro_Const:
+ ir_fprintf(F, "%T ", get_Const_tarval(n));
+ break;
+
case iro_Proj:
pred = get_Proj_pred(n);
proj_nr = get_Proj_proj(n);
return;
}
- mode = get_irn_mode(node);
+ mode = get_irn_mode(n);
if(mode == mode_M) {
print_vcg_color(F, ird_color_memory);
return;
/* Adds a new node info dumper callback. */
void *dump_add_node_info_callback(dump_node_info_cb_t *cb, void *data)
{
- hook_entry_t *info = xmalloc(sizeof(*info));
+ hook_entry_t *info = XMALLOC(hook_entry_t);
info->hook._hook_node_info = cb;
info->context = data;
/**
* Dump the node information of a node n to a file F.
*/
-static INLINE int dump_node_info(FILE *F, ir_node *n)
+static inline int dump_node_info(FILE *F, ir_node *n)
{
int bad = 0;
const ir_op_ops *ops = get_op_ops(get_irn_op(n));
return bad;
}
-static INLINE int is_constlike_node(const ir_node *node)
+static inline int is_constlike_node(const ir_node *node)
{
const ir_op *op = get_irn_op(node);
return is_op_constlike(op);
for (i = 0; i < get_irn_arity(n); i++) {
ir_node *con = get_irn_n(n, i);
- if (is_constlike_node(con) && irn_not_visited(con)) {
+ if (is_constlike_node(con) && !irn_visited(con)) {
int bad = 0;
mark_irn_visited(con);
if(dump_node_edge_hook)
dump_node_edge_hook(F, n);
-#if DO_HEAPANALYSIS
- dump_irn_chi_term(F, n);
- dump_irn_state(F, n);
-#endif
}
/** dump the edge to the block this node belongs to */
/** dump edges to our inputs */
static void dump_ir_data_edges(FILE *F, ir_node *n) {
int i, num;
- unsigned long visited = get_irn_visited(n);
+ ir_visited_t visited = get_irn_visited(n);
if (!dump_keepalive && is_End(n)) {
/* the End node has only keep-alive edges */
PRINT_NODEID(block);
fprintf(F, "\" label: \"");
dump_node_label(F, block);
-#if DO_HEAPANALYSIS
- if (get_opt_dump_abstvals())
- fprintf(F, " seqno: %d", (int)get_Block_seqno(block));
-#endif
/* colorize blocks */
if (! get_Block_matured(block))
/* Close the vcg information for the block */
fprintf(F, "}\n");
dump_const_node_local(F, block);
-#if DO_HEAPANALYSIS
- dump_irn_chi_term(F, block);
-#endif
fprintf(F, "\n");
}
}
-void dump_entity_node(FILE *F, ir_entity *ent, int color)
+void dump_entity_node(FILE *F, ir_entity *ent)
{
fprintf(F, "node: {title: \"");
PRINT_ENTID(ent); fprintf(F, "\"");
fprintf(F, DEFAULT_TYPE_ATTRIBUTE);
fprintf(F, "label: ");
- fprintf(F, "\"ent %s\" ", get_ent_dump_name(ent));
- if (color)
- fprintf(F, "color:%d", color);
- else
- fprintf(F, ENTITY_NODE_ATTR);
+ fprintf(F, "\"%s\" ", get_ent_dump_name(ent));
+
+ print_vcg_color(F, ird_color_entity);
fprintf(F, "\n info1: \"");
dump_entity_to_file(F, ent, dump_verbosity_entattrs | dump_verbosity_entconsts);
fprintf(F, "\n info1: \"value: %s\"}\n", buf);
}
-/* dumps a type or entity and it's edges. */
-static void
-dump_type_info(type_or_ent tore, void *env) {
+/**
+ * Dumps a new style initializer.
+ */
+static void dump_entity_initializer(FILE *F, const ir_entity *ent) {
+ /* TODO */
+ (void) F;
+ (void) ent;
+}
+
+/** Dumps a type or entity and it's edges. */
+static void dump_type_info(type_or_ent tore, void *env) {
FILE *F = env;
int i = 0; /* to shutup gcc */
ir_entity *ent = tore.ent;
ir_node *value;
/* The node */
- dump_entity_node(F, ent, 0);
+ dump_entity_node(F, ent);
/* The Edges */
/* skip this to reduce graph. Member edge of type is parallel to this edge. *
fprintf(F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
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 = 0; i < get_entity_n_overwrites(ent); i++)
- print_ent_ent_edge(F,ent, get_entity_overwrites(ent, i), 0, ENT_OVERWRITES_EDGE_ATTR);
+ 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);
}
/* attached subgraphs */
if (const_entities && (get_entity_variability(ent) != variability_uninitialized)) {
}
}
if (is_compound_entity(ent)) {
- for (i = 0; i < get_compound_ent_n_values(ent); i++) {
- 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, 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);
- */
+ if (has_entity_initializer(ent)) {
+ /* new style initializers */
+ dump_entity_initializer(F, ent);
+ } else {
+ /* old style compound entity values */
+ for (i = get_compound_ent_n_values(ent) - 1; i >= 0; --i) {
+ 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);
+ /*
+ fprintf(F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
+ ENT_CORR_EDGE_ATTR "}\n", GET_ENTID(ent),
+ get_compound_ent_value_member(ent, i), i);
+ */
+ }
}
}
}
/* and now the edges */
switch (get_type_tpop_code(tp)) {
case tpo_class:
- for (i=0; i < get_class_n_supertypes(tp); i++)
- print_type_type_edge(F, tp,get_class_supertype(tp, i),TYPE_SUPER_EDGE_ATTR);
- for (i=0; i < get_class_n_members(tp); i++)
- print_type_ent_edge(F,tp,get_class_member(tp, i),TYPE_MEMBER_EDGE_ATTR);
+ for (i = get_class_n_supertypes(tp) - 1; 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)
+ print_type_ent_edge(F, tp, get_class_member(tp, i), TYPE_MEMBER_EDGE_ATTR);
break;
case tpo_struct:
- for (i=0; i < get_struct_n_members(tp); i++)
- print_type_ent_edge(F,tp,get_struct_member(tp, i),TYPE_MEMBER_EDGE_ATTR);
+ for (i = get_struct_n_members(tp) - 1; i >= 0; --i)
+ print_type_ent_edge(F, tp, get_struct_member(tp, i), TYPE_MEMBER_EDGE_ATTR);
break;
case tpo_method:
- for (i = 0; i < get_method_n_params(tp); i++)
- print_type_type_edge(F,tp,get_method_param_type(tp, i),METH_PAR_EDGE_ATTR,i);
- for (i = 0; i < get_method_n_ress(tp); i++)
- print_type_type_edge(F,tp,get_method_res_type(tp, i),METH_RES_EDGE_ATTR,i);
+ for (i = get_method_n_params(tp) - 1; 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)
+ print_type_type_edge(F, tp, get_method_res_type(tp, i), METH_RES_EDGE_ATTR,i);
break;
case tpo_union:
- for (i = 0; i < get_union_n_members(tp); i++)
- print_type_ent_edge(F,tp,get_union_member(tp, i),UNION_EDGE_ATTR);
+ for (i = get_union_n_members(tp) - 1; 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 = 0; i < get_array_n_dimensions(tp); i++) {
+ 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));
}
break;
case tpo_enumeration:
- for (i = 0; i < get_enumeration_n_enums(tp); ++i) {
+ for (i = get_enumeration_n_enums(tp) - 1; i >= 0; --i) {
dump_enum_item(F, tp, i);
print_enum_item_edge(F, tp, i, "label: \"item %d\"", i);
}
break;
case tpo_pointer:
- print_type_type_edge(F,tp,get_pointer_points_to_type(tp), PTR_PTS_TO_EDGE_ATTR);
+ print_type_type_edge(F, tp, get_pointer_points_to_type(tp), PTR_PTS_TO_EDGE_ATTR);
break;
case tpo_primitive:
break;
break; /* GL */
if (env->dump_ent && is_Class_type(get_entity_owner(ent))) {
/* The node */
- dump_entity_node(F, ent, 0);
+ dump_entity_node(F, ent);
/* The edges */
- print_type_ent_edge(F,get_entity_owner(ent),ent,TYPE_MEMBER_EDGE_ATTR);
- for(i = 0; i < get_entity_n_overwrites(ent); i++)
- print_ent_ent_edge(F, get_entity_overwrites(ent, i), ent, 0, ENT_OVERWRITES_EDGE_ATTR);
+ 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);
}
break;
}
case tpo_class:
dump_type_node(F, tp);
/* and now the edges */
- for (i=0; i < get_class_n_supertypes(tp); i++) {
+ for (i = get_class_n_supertypes(tp) - 1; i >= 0; --i) {
print_type_type_edge(F,tp,get_class_supertype(tp, i),TYPE_SUPER_EDGE_ATTR);
}
break;
dump_out_edge(ir_node *n, void *env) {
FILE *F = env;
int i;
- for (i = 0; i < get_irn_n_outs(n); i++) {
- assert(get_irn_out(n, i));
+ for (i = get_irn_n_outs(n) - 1; i >= 0; --i) {
+ ir_node *succ = get_irn_out(n, i);
+ assert(succ);
fprintf(F, "edge: {sourcename: \"");
PRINT_NODEID(n);
fprintf(F, "\" targetname: \"");
- PRINT_NODEID(get_irn_out(n, i));
+ PRINT_NODEID(succ);
fprintf(F, "\" color: red linestyle: dashed");
fprintf(F, "}\n");
}
}
-static INLINE void
+static inline void
dump_loop_label(FILE *F, 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));
}
-static INLINE void dump_loop_info(FILE *F, ir_loop *loop) {
+static inline void dump_loop_info(FILE *F, ir_loop *loop) {
fprintf(F, " info1: \"");
fprintf(F, " loop nr: %d", get_loop_loop_nr(loop));
#ifdef DEBUG_libfirm /* GL @@@ debug analyses */
fprintf(F, "\"");
}
-static INLINE void
+static inline void
dump_loop_node(FILE *F, ir_loop *loop) {
fprintf(F, "node: {title: \"");
PRINT_LOOPID(loop);
fprintf(F, "}\n");
}
-static INLINE void
+static inline void
dump_loop_node_edge(FILE *F, ir_loop *loop, int i) {
assert(loop);
fprintf(F, "edge: {sourcename: \"");
fprintf(F, "}\n");
}
-static INLINE void
+static inline void
dump_loop_son_edge(FILE *F, ir_loop *loop, int i) {
assert(loop);
fprintf(F, "edge: {sourcename: \"");
/* dump edges to nodes in loop -- only if it is a real loop */
if (get_loop_depth(loop) != 0) {
- for (i = 0; i < get_loop_n_nodes(loop); i++) {
+ for (i = get_loop_n_nodes(loop) - 1; i >= 0; --i) {
dump_loop_node_edge(F, loop, i);
}
}
- for (i = 0; i < get_loop_n_sons(loop); i++) {
+ for (i = get_loop_n_sons(loop) - 1; i >= 0; --i) {
dump_loops(F, get_loop_son(loop, i));
dump_loop_son_edge(F, loop, i);
}
}
-static INLINE
+static inline
void dump_loop_nodes_into_graph(FILE *F, ir_graph *irg) {
- ir_graph *rem = current_ir_graph;
- current_ir_graph = irg;
+ ir_loop *loop = get_irg_loop(irg);
+
+ if (loop != NULL) {
+ ir_graph *rem = current_ir_graph;
+ current_ir_graph = irg;
- if (get_irg_loop(irg)) dump_loops(F, get_irg_loop(irg));
+ dump_loops(F, loop);
- current_ir_graph = rem;
+ current_ir_graph = rem;
+ }
}
* @param suffix1 first filename suffix
* @param suffix2 second filename suffix
*/
-FILE *vcg_open(ir_graph *irg, const char * suffix1, const char *suffix2) {
+FILE *vcg_open(ir_graph *irg, const char *suffix1, const char *suffix2) {
FILE *F;
const char *nm = get_irg_dump_name(irg);
int len = strlen(nm), i, j;
if (!suffix2) suffix2 = "";
/* open file for vcg graph */
- fname = xmalloc (len * 2 + strlen(suffix1) + strlen(suffix2) + 5);
+ fname = XMALLOCN(char, len * 2 + strlen(suffix1) + strlen(suffix2) + 5);
/* strncpy (fname, nm, len); */ /* copy the filename */
j = 0;
if (!F) {
perror(fname);
}
- free(fname);
+ xfree(fname);
return F;
}
if (!suffix) suffix = "";
/** open file for vcg graph */
- fname = xmalloc(len * 2 + 5 + strlen(suffix));
+ fname = XMALLOCN(char, len * 2 + 5 + strlen(suffix));
/* strcpy (fname, name);*/ /* copy the filename */
j = 0;
for (i = 0; i < len; ++i) { /* replace '/' in the name: escape by @. */
if (!F) {
perror(fname);
}
- free(fname);
+ xfree(fname);
return F;
}
dump_irnode_to_file(F, block);
/* Check whether we have bad predecessors to color the block. */
- for (i = 0; i < get_Block_n_cfgpreds(block); ++i)
+ for (i = get_Block_n_cfgpreds(block) - 1; i >= 0; --i)
if ((fl = is_Bad(get_Block_cfgpred(block, i))))
break;
fprintf(F, "}\n");
/* Dump the edges */
- for ( i = 0; i < get_Block_n_cfgpreds(block); i++)
- if (get_irn_op(skip_Proj(get_Block_cfgpred(block, i))) != op_Bad) {
+ 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);
static void descend_and_dump(FILE *F, ir_node *n, int depth, pset *mark_set) {
- if (pset_find_ptr(mark_set, n)) return;
+ if (pset_find_ptr(mark_set, n))
+ return;
pset_insert_ptr(mark_set, n);
}
}
-#ifdef INTERPROCEDURAL_VIEW
void dump_callgraph(const char *suffix) {
FILE *F = vcg_open_name("Callgraph", suffix);
int i, rem = edge_label;
//int colorize;
edge_label = 1;
- dump_vcg_header(F, "Callgraph", NULL);
-
- //colorize = get_irp_callgraph_state() == irp_callgraph_and_calltree_consistent;
+ dump_vcg_header(F, "Callgraph", "Hierarchiv", NULL);
for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
ir_graph *irg = get_irp_irg(i);
ir_entity *ent = get_irg_entity(irg);
int j;
- //int n_callees = get_irg_n_callees(irg);
- int color;
+ int n_callees = get_irg_n_callees(irg);
- //color = colorize ? get_entity_color(ent) : ird_color_green;
- color = ird_color_green;
- dump_entity_node(F, ent, color);
+ dump_entity_node(F, ent);
for (j = 0; j < n_callees; ++j) {
ir_entity *c = get_irg_entity(get_irg_callee(irg, j));
//if (id_is_prefix(prefix, get_entity_ld_ident(c))) continue;
int be = is_irg_callee_backedge(irg, j);
char *attr;
attr = (be) ?
- "label:\"recursion %d\" color:%d" :
- "label:\"calls %d\" color:%d";
- print_ent_ent_edge(F, ent, c, be, attr, get_irg_callee_loop_depth(irg, j), color);
+ "label:\"recursion %d\"" :
+ "label:\"calls %d\"";
+ print_ent_ent_edge(F, ent, c, be, ird_color_entity, attr, get_irg_callee_loop_depth(irg, j));
}
}
}
}
+#if 0
/* Dump all irgs in interprocedural view to a single file. */
void dump_all_cg_block_graph(const char *suffix) {
FILE *f = vcg_open_name("All_graphs", suffix);
dump_all_types(const char *suffix)
{
FILE *f = vcg_open_name("All_types", suffix);
- if (f) {
+ if (f != NULL) {
dump_vcg_header(f, "All_types", "Hierarchic", NULL);
type_walk(dump_type_info, NULL, f);
inc_irg_visited(get_const_code_irg());
FILE *f;
/* if a filter is set, dump only the irg's that match the filter */
- if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg)))) return;
+ if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
+ return;
f = vcg_open(irg, suffix, "-looptree");
if (f != NULL) {