* Copyright: (c) 1998-2003 Universität Karlsruhe
* Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
*/
+#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 "entity_t.h"
#include "irop_t.h"
-#include "irdump.h"
+#include "irdump_t.h"
#include "irgwalk.h"
#include "typewalk.h"
#include "array.h"
#include "pmap.h"
#include "eset.h"
+#include "pset.h"
#if DO_HEAPANALYSIS
-void dump_chi_term(FILE *FL, ir_node *n);
-void dump_state(FILE *FL, ir_node *n);
-int get_opt_dump_abstvals(void);
+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;
-SeqNo get_Block_seqno(ir_node *n);
+extern SeqNo get_Block_seqno(ir_node *n);
#endif
-/* 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 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 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 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 %d\" color: green"
-#define METH_RES_EDGE_ATTR "class: 6 label: \"res %d\" 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 %d corresponds to \" "
-#define TYPE_MEMBER_EDGE_ATTR "class: 12 label: \"member\" color:blue"
-#define ENUM_ITEM_NODE_ATTR "color: green"
-#define CALLGRAPH_EDGE_ATTR "calls"
-
-#if DEBUG_libfirm && NODEID_AS_LABEL
-#define PRINT_NODEID(X) fprintf(F, "n%ld", get_irn_node_nr(X))
-#define PRINT_TYPEID(X) fprintf(F, "\"t%ld\"", get_type_nr(X))
-#define PRINT_ENTID(X) fprintf(F, "e%ld", get_entity_nr(X))
-#define PRINT_IRGID(X) fprintf(F, "g%ld", get_irg_graph_nr(X))
-#define PRINT_CONSTID(X,Y) fprintf(F, "\"n%ldn%ld\"", get_irn_node_nr(X),get_irn_node_nr(Y))
-#define PRINT_LOOPID(X) fprintf(F, "l%d", get_loop_loop_nr(X))
-#define PRINT_ITEMID(X,Y) fprintf(F, "i%ldT%d", get_type_nr(X), (Y))
-
-#else
-#define PRINT_NODEID(X) fprintf(F, "n%p", (void *)(X))
-#define PRINT_TYPEID(X) fprintf(F, "\"t%p\"", (void *)(X))
-#define PRINT_ENTID(X) fprintf(F, "e%p", (void *)(X))
-#define PRINT_IRGID(X) fprintf(F, "g%p",(void *)(X))
-#define PRINT_CONSTID(X,Y) fprintf(F, "\"n%pn%p\"", (void*)(X), (void*)(Y))
-#define PRINT_LOOPID(X) fprintf(F, "l%p", (void *)(X))
-#define PRINT_ITEMID(X,Y) fprintf(F, "i%pT%d", (void *) (X), (Y))
-#endif
-
-
/* basis for a color range for vcg */
static int n_colors = 0;
static int base_color = 0;
-static const char *get_mode_name_ex(ir_mode *mode, int *bad)
+#define ERROR_TXT "<ERROR>"
+
+/**
+ * returns the name of a mode or <ERROR> if mode is NOT a mode object.
+ * in the later case, sets bad
+ */
+const char *get_mode_name_ex(ir_mode *mode, int *bad)
{
if (is_mode(mode))
return get_mode_name(mode);
*bad |= 1;
- return "<ERROR>";
+ return ERROR_TXT;
}
-static const char *get_type_name_ex(type *tp, int *bad)
+/**
+ * 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(type *tp, int *bad)
{
if (is_type(tp))
return get_type_name(tp);
*bad |= 1;
- return "<ERROR>";
+ return ERROR_TXT;
}
+/**
+ * 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, type *S, type *T, const char *fmt, ...)
{
va_list ap;
va_end(ap);
}
+/**
+ * prints the edge from a type T to an entity E with additional info fmt, ...
+ * to the file F
+ */
static void print_type_ent_edge(FILE *F, type *T, entity *E, const char *fmt, ...)
{
va_list ap;
va_end(ap);
}
+/**
+ * prints the edge from an entity E to an entity T with additional info fmt, ...
+ * to the file F
+ */
static void print_ent_ent_edge(FILE *F, entity *E, entity *T, int backedge, const char *fmt, ...)
{
va_list ap;
va_end(ap);
}
+/**
+ * prints the edge from an entity E to a type T with additional info fmt, ...
+ * to the file F
+ */
static void print_ent_type_edge(FILE *F, entity *E, type *T, const char *fmt, ...)
{
va_list ap;
va_end(ap);
}
+/**
+ * prints the edge from a node N to a type T with additional info fmt, ...
+ * to the file F
+ */
static void print_node_type_edge(FILE *F, const ir_node *N, type *T, const char *fmt, ...)
{
va_list ap;
va_end(ap);
}
+/**
+ * prints the edge from a node N to an entity E with additional info fmt, ...
+ * to the file F
+ */
static void print_node_ent_edge(FILE *F, const ir_node *N, entity *E, const char *fmt, ...)
{
va_list ap;
va_end(ap);
}
+/**
+ * prints the edge from an entity E to a node N with additional info fmt, ...
+ * to the file F
+ */
static void print_ent_node_edge(FILE *F, entity *E, const ir_node *N, const char *fmt, ...)
{
va_list ap;
va_end(ap);
}
+/**
+ * prints the edge from a type E to an enumeration item item with additional info fmt, ...
+ * to the file F
+ */
static void print_enum_item_edge(FILE *F, type *E, int item, const char *fmt, ...)
{
va_list ap;
va_end(ap);
}
-/*******************************************************************/
+/*-----------------------------------------------------------------*/
/* global and ahead declarations */
-/*******************************************************************/
+/*-----------------------------------------------------------------*/
static void dump_whole_node(ir_node *n, void *env);
static INLINE void dump_loop_nodes_into_graph(FILE *F, ir_graph *irg);
-/*******************************************************************/
+/*-----------------------------------------------------------------*/
/* Helper functions. */
-/*******************************************************************/
-
-/* Use private link attr to be able to call dumper anywhere without
- destroying link fields. */
+/*-----------------------------------------------------------------*/
+/**
+ * This map is used as a private link attr to be able to call dumper
+ * anywhere without destroying link fields.
+ */
static pmap *irdump_link_map = NULL;
+/** Creates the link attribut map. */
static void init_irdump(void) {
/* We need a new, empty map. */
if (irdump_link_map) pmap_destroy(irdump_link_map);
irdump_link_map = pmap_create();
}
-
-void *ird_get_irn_link(ir_node *n) {
+/**
+ * Returns the private link field.
+ */
+static void *ird_get_irn_link(ir_node *n) {
void *res = NULL;
if (!irdump_link_map) return NULL;
return res;
}
-void ird_set_irn_link(ir_node *n, void *x) {
+/**
+ * Sets the private link field.
+ */
+static void ird_set_irn_link(ir_node *n, void *x) {
if (!irdump_link_map) init_irdump();
pmap_insert(irdump_link_map, (void *)n, x);
}
-void *ird_get_irg_link(ir_graph *irg) {
+/**
+ * Gets the private link field of an irg.
+ */
+static void *ird_get_irg_link(ir_graph *irg) {
void *res = NULL;
if (!irdump_link_map) return NULL;
return res;
}
-void ird_set_irg_link(ir_graph *irg, void *x) {
+/**
+ * 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);
}
+/**
+ * Walker, clears tzhe private link field
+ */
static void clear_link(ir_node * node, void * env) {
ird_set_irn_link(node, NULL);
}
-
-static int node_floats(ir_node *n) {
- return ((get_irn_pinned(n) == op_pin_state_floats) &&
- (get_irg_pinned(current_ir_graph) == op_pin_state_floats));
-}
-
+/**
+ * If the entity has a ld_name, returns it, else returns the name of the entity.
+ */
const char *get_ent_dump_name(entity *ent) {
- if (! ent)
+ if (!ent)
return "<NULL entity>";
/* 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);
return get_id_str(ent->name);
}
+/* Returns the name of an IRG. */
const char *get_irg_dump_name(ir_graph *irg) {
/* Don't use get_entity_ld_ident (ent) as it computes the mangled name! */
entity *ent = get_irg_entity(irg);
return get_ent_dump_name(ent);
}
+/**
+ * Returns non-zero if a node is in floating state.
+ */
+static int node_floats(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) {
if (is_Block(node)
|| node_floats(node)
|| get_irn_op(node) == op_Bad
- || get_irn_op(node) == op_Unknown) {
+ || get_irn_op(node) == op_Unknown
+ || get_irn_op(node) == op_NoMem) {
ir_node ** arr = (ir_node **) ird_get_irg_link(get_irn_irg(node));
if (!arr) arr = NEW_ARR_F(ir_node *, 0);
ARR_APP1(ir_node *, arr, node);
ird_set_irg_link(get_irn_irg(node), arr); /* arr is an l-value, APP_ARR might change it! */
} else {
ir_node * block = get_nodes_block(node);
- ird_set_irn_link(node, ird_get_irn_link(block));
- ird_set_irn_link(block, node);
+
+ if (is_Bad(block)) {
+ /* this node is in a Bad block, so we must place it into the graph's list */
+ ir_node ** arr = (ir_node **) ird_get_irg_link(get_irn_irg(node));
+ if (!arr) arr = NEW_ARR_F(ir_node *, 0);
+ ARR_APP1(ir_node *, arr, node);
+ ird_set_irg_link(get_irn_irg(node), arr); /* arr is an l-value, APP_ARR might change it! */
+ }
+ else {
+ ird_set_irn_link(node, ird_get_irn_link(block));
+ ird_set_irn_link(block, node);
+ }
}
}
/** Construct lists to walk ir block-wise.
*
* Collects all blocks, nodes not op_pin_state_pinned,
- * Bad and Unknown into a flexible array in link field of
+ * Bad, NoMem and Unknown into a flexible array in link field of
* irg they belong to. Sets the irg link field to NULL in all
* graphs not visited.
- * Free the list with DEL_ARR_F. */
+ * Free the list with DEL_ARR_F().
+ */
static ir_node ** construct_block_lists(ir_graph *irg) {
- int i, rem_view = interprocedural_view;
+ int i, rem_view = get_interprocedural_view();
ir_graph *rem = current_ir_graph;
current_ir_graph = irg;
irg_walk_graph(current_ir_graph, clear_link, collect_node, current_ir_graph);
/* Collect also EndReg and EndExcept. We do not want to change the walker. */
- interprocedural_view = 0;
+ set_interprocedural_view(false);
+
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);
- interprocedural_view = rem_view;
+
+ set_interprocedural_view(rem_view);
current_ir_graph = rem;
return ird_get_irg_link(irg);
/* flags to steer output */
/*******************************************************************/
+/** Dump only irgs with names start with this string */
const char *dump_file_filter = "";
-/* A compiler option to turn off edge labels */
-int edge_label = 1;
-/* A compiler option to turn off dumping values of constant entities */
-int const_entities = 1;
-/* A compiler option to dump the keep alive edges */
-int dump_keepalive = 0;
-/* Compiler options to dump analysis information in dump_ir_graph */
+/** A compiler option to turn off edge labels */
+static int edge_label = 1;
+/** A compiler option to turn off dumping values of constant entities */
+static int const_entities = 1;
+/** A compiler option to dump the keep alive edges */
+static int dump_keepalive = 0;
+/** Compiler options to dump analysis information in dump_ir_graph */
int dump_out_edge_flag = 0;
int dump_dominator_information_flag = 0;
int dump_loop_information_flag = 0;
bool opt_dump_analysed_type_info = 1;
bool opt_dump_pointer_values_to_info = 0; /* default off: for test compares!! */
-char* overrule_nodecolor = NULL;
+static const char *overrule_nodecolor = NULL;
+
+/** The vcg attribute hook. */
+static DUMP_NODE_VCGATTR_FUNC dump_node_vcgattr_hook = NULL;
+
+/* set the hook */
+void set_dump_node_vcgattr_hook(DUMP_NODE_VCGATTR_FUNC hook)
+{
+ dump_node_vcgattr_hook = hook;
+}
INLINE bool get_opt_dump_const_local(void) {
if (!dump_out_edge_flag && !dump_loop_information_flag)
dump_const_local = b;
}
-void turn_off_constant_entity_values(void) {
- const_entities = 0;
+void dump_constant_entity_values(bool b) {
+ const_entities = b;
}
void dump_keepalive_edges(bool b) {
return dump_keepalive;
}
-void dump_out_edges(void) {
- dump_out_edge_flag = 1;
-}
-
-void dump_dominator_information(void) {
- dump_dominator_information_flag = 1;
+void dump_out_edges(bool b) {
+ dump_out_edge_flag = b;
}
-void dump_loop_information(void) {
- dump_loop_information_flag = 1;
+void dump_dominator_information(bool b) {
+ dump_dominator_information_flag = b;
}
-void dont_dump_loop_information(void) {
- dump_loop_information_flag = 0;
+void dump_loop_information(bool b) {
+ dump_loop_information_flag = b;
}
void dump_backedge_information(bool b) {
* If the flag is set, the type name is output in [] in the node label,
* else it is output as info.
*/
-void dump_analysed_type_info(bool b) {
+void set_opt_dump_analysed_type_info(bool b) {
opt_dump_analysed_type_info = b;
}
/* Routines to dump information about a single ir node. */
/*-----------------------------------------------------------------*/
-INLINE int
+/*
+ * dump the name of a node n to the File F.
+ */
+int
dump_node_opcode(FILE *F, ir_node *n)
{
int bad = 0;
} break;
case iro_Filter: {
- if (!interprocedural_view) fprintf(F, "Proj'");
- else goto default_case;
+ if (!get_interprocedural_view())
+ fprintf(F, "Proj'");
+ else
+ goto default_case;
} break;
case iro_Proj: {
case iro_End:
case iro_EndExcept:
case iro_EndReg: {
- if (interprocedural_view) {
+ 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
return bad;
}
+/**
+ * Dump the mode of a node n to a file F.
+ * Ignore modes that are "always known".
+ */
static INLINE int
dump_node_mode(FILE *F, ir_node *n)
{
case iro_Free:
case iro_Sync:
case iro_Jmp:
+ case iro_NoMem:
break;
default: {
ir_mode *mode = get_irn_mode(n);
return bad;
}
+/**
+ * Dump the tpe of a node n to a file F if it's known.
+ */
static int dump_node_typeinfo(FILE *F, ir_node *n) {
int bad = 0;
if (opt_dump_analysed_type_info) {
- if (get_irg_typeinfo_state(current_ir_graph) == irg_typeinfo_consistent ||
- get_irg_typeinfo_state(current_ir_graph) == irg_typeinfo_inconsistent) {
- type *tp = get_irn_type(n);
- if (tp != none_type)
- fprintf(F, " [%s]", get_type_name_ex(tp, &bad));
+ if (get_irg_typeinfo_state(current_ir_graph) == ir_typeinfo_consistent ||
+ get_irg_typeinfo_state(current_ir_graph) == ir_typeinfo_inconsistent) {
+ type *tp = get_irn_typeinfo_type(n);
+ if (tp != firm_none_type)
+ fprintf(F, "[%s] ", get_type_name_ex(tp, &bad));
else
- fprintf(F, " []");
+ fprintf(F, "[] ");
}
}
return bad;
}
+/**
+ * Dump addinional node attributes of some nodes to a file F.
+ */
static INLINE int
dump_node_nodeattr(FILE *F, ir_node *n)
{
switch (get_irn_opcode(n)) {
case iro_Start:
- if (false && interprocedural_view) {
- fprintf (F, "%s", get_ent_dump_name(get_irg_entity(current_ir_graph)));
+ if (false && get_interprocedural_view()) {
+ fprintf (F, "%s ", get_ent_dump_name(get_irg_entity(current_ir_graph)));
}
break;
case iro_Proj:
if (get_irn_opcode(get_Proj_pred(n)) == iro_Cmp) {
- fprintf (F, "%s", get_pnc_string(get_Proj_proj(n)));
+ fprintf (F, "%s ", get_pnc_string(get_Proj_proj(n)));
} else {
- fprintf (F, "%ld", get_Proj_proj(n));
+ fprintf (F, "%ld ", get_Proj_proj(n));
}
break;
case iro_Filter:
- fprintf (F, "%ld", get_Filter_proj(n));
+ fprintf (F, "%ld ", get_Filter_proj(n));
+ break;
+ case iro_Sel:
+ fprintf (F, "%s ", get_ent_dump_name(get_Sel_entity(n)));
+ break;
+ case iro_Cast:
+ fprintf (F, "(%s) ", get_type_name_ex(get_Cast_type(n), &bad));
+ break;
+ case iro_Confirm:
+ fprintf (F, "%s ", get_pnc_string(get_Confirm_cmp(n)));
break;
- case iro_Sel: {
- fprintf (F, "%s", get_ent_dump_name(get_Sel_entity(n)));
- } break;
- case iro_Cast: {
- fprintf (F, "(%s)", get_type_name_ex(get_Cast_type(n), &bad));
- } break;
- case iro_Confirm: {
- fprintf (F, "%s", get_pnc_string(get_Confirm_cmp(n)));
- } break;
default:
;
return bad;
}
-static INLINE void dump_node_vcgattr(FILE *F, ir_node *n, int bad)
+
+/** Dumps a node label without the enclosing ". */
+static int dump_node_label(FILE *F, ir_node *n) {
+ int bad = 0;
+
+ bad |= dump_node_opcode(F, n);
+ bad |= dump_node_mode(F, n);
+ fprintf (F, " ");
+ bad |= dump_node_typeinfo(F, n);
+ bad |= dump_node_nodeattr(F, n);
+ fprintf(F, "%ld", get_irn_node_nr(n));
+
+ return bad;
+}
+
+
+/**
+ * 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)
{
+ ir_node *n;
+
if (bad) {
fprintf(F, "color: red");
return;
}
+
+ if (dump_node_vcgattr_hook)
+ if (dump_node_vcgattr_hook(F, node, local))
+ return;
+
+ n = local ? local : node;
+
switch (get_irn_opcode(n)) {
case iro_Start:
case iro_EndReg:
fprintf (F, "color: blue");
break;
case iro_Block:
- fprintf (F, "color: lightyellow");
+ if (is_Block_dead(n))
+ fprintf (F, "color: lightred");
+ else
+ fprintf (F, "color: lightyellow");
break;
case iro_Phi:
fprintf (F, "color: green");
if (overrule_nodecolor) fprintf(F, " color: %s", overrule_nodecolor);
}
-static INLINE int dump_node_info(FILE *F, ir_node *n)
-{
- int i, bad = 0;
- char comma;
- ir_graph *irg;
+/**
+ * Dump the node information of a node n to a file F.
+ */
+static INLINE int dump_node_info(FILE *F, ir_node *n)
+{ int bad = 0;
fprintf (F, " info1: \"");
- if (opt_dump_pointer_values_to_info)
- fprintf (F, "addr: %p \n", (void *)n);
- fprintf (F, "mode: %s\n", get_mode_name(get_irn_mode(n)));
- fprintf (F, "visited: %ld \n", get_irn_visited(n));
- irg = get_irn_irg(n);
- if (irg != get_const_code_irg())
- fprintf (F, "irg: %s\n", get_ent_dump_name(get_irg_entity(irg)));
-
- if (get_irn_pinned(n) == op_pin_state_floats &&
- get_irg_pinned(get_irn_irg(n)) == op_pin_state_floats) {
- fprintf(F, "node was pinned in ");
- dump_node_opcode(F, get_nodes_block(n));
- fprintf(F, " %ld\n", get_irn_node_nr(get_nodes_block(n)));
- }
-
-#if 0
- /* show all predecessor nodes */
- fprintf(F, "pred nodes: \n");
- if (!is_Block(n)) {
- fprintf(F, " -1: ");
- dump_node_opcode(F, get_nodes_block(n));
- fprintf(F, " %ld\n", get_irn_node_nr(get_nodes_block(n)));
- }
- for ( i = 0; i < get_irn_arity(n); ++i) {
- fprintf(F, " %d: ", i);
- dump_node_opcode(F, get_irn_n(n, i));
- fprintf(F, " %ld\n", get_irn_node_nr(get_irn_n(n, i)));
- }
-#endif
-
- fprintf(F, "arity: %d", get_irn_arity(n));
- if ((get_irn_op(n) == op_Block) ||
- (get_irn_op(n) == op_Phi) ||
- ((get_irn_op(n) == op_Filter) && interprocedural_view)) {
- fprintf(F, " backedges:");
- comma = ' ';
- for (i = 0; i < get_irn_arity(n); i++)
- if (is_backedge(n, i)) { fprintf(F, "%c %d", comma, i); comma = ','; }
- }
- fprintf(F, "\n");
-
- /* Loop node Someone else please tell me what's wrong ...
- if (get_irn_loop(n)) {
- ir_loop *loop = get_irn_loop(n);
- assert(loop);
- fprintf(F, " in loop %d with depth %d\n",
- get_loop_loop_nr(loop), get_loop_depth(loop));
- }
- */
-
- /* Source types */
- switch (get_irn_opcode(n)) {
- case iro_Start: {
- type *tp = get_entity_type(get_irg_entity(get_irn_irg(n)));
- fprintf(F, "start of method of type %s \n", get_type_name_ex(tp, &bad));
- for (i = 0; i < get_method_n_params(tp); ++i)
- fprintf(F, " param %d type: %s \n", i, get_type_name_ex(get_method_param_type(tp, i), &bad));
- if ((get_irp_ip_view_state() == ip_view_valid) && !interprocedural_view) {
- ir_node *sbl = get_nodes_block(n);
- int i, n_cfgpreds = get_Block_cg_n_cfgpreds(sbl);
- fprintf(F, "graph has %d interprocedural predecessors:\n", n_cfgpreds);
- for (i = 0; i < n_cfgpreds; ++i) {
- ir_node *cfgpred = get_Block_cg_cfgpred(sbl, i);
- fprintf(F, " %d: Call %ld in graph %s\n", i, get_irn_node_nr(cfgpred),
- get_irg_dump_name(get_irn_irg(cfgpred)));
- }
- }
- } break;
- case iro_Alloc: {
- fprintf(F, "allocating entity of type %s \n", get_type_name_ex(get_Alloc_type(n), &bad));
- } break;
- case iro_Free: {
- fprintf(F, "freeing entity of type %s \n", get_type_name_ex(get_Free_type(n), &bad));
- } break;
- case iro_Sel: {
- entity *ent = get_Sel_entity(n);
-
- if (ent) {
- fprintf(F, "Selecting entity of type %s\n", get_type_name_ex(get_entity_type(ent), &bad));
- fprintf(F, " from entity of type %s\n", get_type_name_ex(get_entity_owner(ent), &bad));
- }
- else {
- fprintf(F, "<NULL entity>\n");
- bad = 1;
- }
- } break;
- case iro_Call: {
- type *tp = get_Call_type(n);
- fprintf(F, "calling method of type %s \n", get_type_name_ex(tp, &bad));
- for (i = 0; i < get_method_n_params(tp); ++i)
- fprintf(F, " param %d type: %s \n", i, get_type_name_ex(get_method_param_type(tp, i), &bad));
- for (i = 0; i < get_method_n_ress(tp); ++i)
- fprintf(F, " resul %d type: %s \n", i, get_type_name_ex(get_method_res_type(tp, i), &bad));
- if (Call_has_callees(n)) {
- fprintf(F, "possible callees: \n");
- for (i = 0; i < get_Call_n_callees(n); i++) {
- if (!get_Call_callee(n, i)) {
- fprintf(F, " %d external method\n", i);
- } else {
- fprintf(F, " %d: %s\n", i, get_ent_dump_name(get_Call_callee(n, i)));
- }
- }
- }
- } break;
- case iro_CallBegin: {
- ir_node *call = get_CallBegin_call(n);
- if (Call_has_callees(call)) {
- fprintf(F, "possible callees: \n");
- for (i = 0; i < get_Call_n_callees(call); i++) {
- if (!get_Call_callee(call, i)) {
- fprintf(F, " %d external method\n", i);
- } else {
- fprintf(F, " %d: %s\n", i, get_ent_dump_name(get_Call_callee(call, i)));
- }
- }
- }
- } break;
- case iro_Return: {
- if (!interprocedural_view) {
- type *tp = get_entity_type(get_irg_entity(get_irn_irg(n)));
- fprintf(F, "return in method of type %s \n", get_type_name_ex(tp, &bad));
- for (i = 0; i < get_method_n_ress(tp); ++i)
- fprintf(F, " res %d type: %s \n", i, get_type_name_ex(get_method_res_type(tp, i), &bad));
- }
- } break;
- case iro_Const: {
- type *tp = get_Const_type(n);
- assert(tp != none_type);
- fprintf(F, "Const of type %s \n", get_type_name_ex(get_Const_type(n), &bad));
- } break;
- case iro_SymConst: {
- switch(get_SymConst_kind(n)) {
- case symconst_addr_name:
- fprintf(F, "kind addr_name\n");
- break;
- case symconst_addr_ent:
- fprintf(F, "kind addr_ent\n");
- dump_entity_to_file(F, get_SymConst_entity(n), dump_verbosity_onlynames);
- break;
- case symconst_type_tag:
- fprintf(F, "kind type_tag\n");
- break;
- case symconst_size:
- fprintf(F, "kind size\n");
- break;
- }
- } break;
- case iro_Filter: {
- int i;
- if (interprocedural_view) {
- fprintf(F, "intra predecessor nodes:\n");
- for (i = 0; i < get_irn_intra_arity(n); i++) {
- ir_node *pred = get_irn_intra_n(n, i);
- fprintf(F, " %s%s %ld\n", get_irn_opname(pred), get_irn_modename(pred), get_irn_node_nr(pred));
- }
- } else {
- fprintf(F, "inter predecessor nodes:\n");
- for (i = 0; i < get_irn_inter_arity(n); i++) {
- ir_node *pred = get_irn_inter_n(n, i);
- fprintf(F, " %s%s %ld \tin graph %s\n", get_irn_opname(pred), get_irn_modename(pred),
- get_irn_node_nr(pred), get_ent_dump_name(get_irg_entity(get_irn_irg(pred))));
- }
- }
- } break;
- case iro_Load:
- fprintf(F, "volatility: %s\n", get_volatility_name(get_Load_volatility(n)));
- break;
- case iro_Store:
- fprintf(F, "volatility: %s\n", get_volatility_name(get_Store_volatility(n)));
- break;
-
- default: ;
- }
-
- if (get_irg_typeinfo_state(get_irn_irg(n)) == irg_typeinfo_consistent ||
- get_irg_typeinfo_state(get_irn_irg(n)) == irg_typeinfo_inconsistent )
- if (get_irn_type(n) != none_type)
- fprintf (F, "\nAnalysed type: %s", get_type_name_ex(get_irn_type(n), &bad));
-
- fprintf (F, "\"");
-
+ bad = dump_irnode_to_file(F, n);
+ fprintf(F, "\"\n");
return bad;
}
-
+/**
+ * checks wheater a node is "constant-like", ie can be treated "block-less"
+ */
static INLINE
bool is_constlike_node(ir_node *n) {
ir_op *op = get_irn_op(n);
- return (op == op_Const || op == op_Bad || op == op_SymConst || op == op_Unknown);
+ return (op == op_Const || op == op_Bad || op == op_NoMem || op == op_SymConst || op == op_Unknown);
}
-/* outputs the predecessors of n, that are constants, local. I.e.,
+/** 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) {
int i;
n and const. */
fprintf(F, "node: {title: "); PRINT_CONSTID(n, con);
fprintf(F, " label: \"");
- bad |= dump_node_opcode(F, con);
- bad |= dump_node_mode(F, con);
- bad |= dump_node_typeinfo(F, con);
- fprintf (F, " ");
- bad |= dump_node_nodeattr(F, con);
- fprintf(F, " %ld", get_irn_node_nr(con));
+ bad |= dump_node_label(F, con);
fprintf(F, "\" ");
bad |= dump_node_info(F, con);
- dump_node_vcgattr(F, con, bad);
+ dump_node_vcgattr(F, n, con, bad);
fprintf(F, "}\n");
}
}
}
-static void INLINE print_node_error(FILE *F, const char *p)
+/** 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) {
+ ir_node *blk;
+
+ if (!get_opt_dump_const_local()) return;
+
+ blk = get_nodes_block(n);
+ if (is_constlike_node(blk)) {
+ int bad = 0;
+
+ /* 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: \"");
+ bad |= dump_node_label(F, blk);
+ fprintf(F, "\" ");
+ bad |= dump_node_info(F, blk);
+ dump_node_vcgattr(F, n, blk, bad);
+ fprintf(F, "}\n");
+
+ fprintf (F, "edge: { sourcename: \"");
+ PRINT_NODEID(n);
+ fprintf (F, "\" targetname: \""); PRINT_CONSTBLKID(n,blk);
+ fprintf (F, "\" " BLOCK_EDGE_ATTR "}\n");
+ }
+}
+
+/**
+ * prints the error message of a node to a file F as info2.
+ */
+static void INLINE print_node_error(FILE *F, const char *err_msg)
{
- if (! p)
+ if (! err_msg)
return;
- fprintf (F, " info2: \"%s\"", p);
+ fprintf (F, " info2: \"%s\"", err_msg);
}
+/**
+ * Dump a node
+ */
static void dump_node(FILE *F, ir_node *n)
{
int bad = 0;
const char *p;
- if (get_opt_dump_const_local() && is_constlike_node(n)) return;
+ if (get_opt_dump_const_local() && is_constlike_node(n))
+ return;
+
/* dump this node */
fprintf(F, "node: {title: \""); PRINT_NODEID(n); fprintf(F, "\" label: \"");
bad = ! irn_vrfy_irg_dump(n, current_ir_graph, &p);
- bad |= dump_node_opcode(F, n);
- bad |= dump_node_mode(F, n);
- bad |= dump_node_typeinfo(F, n);
- fprintf(F, " ");
- bad |= dump_node_nodeattr(F, n);
- fprintf(F, " %ld", get_irn_node_nr(n));
+ bad |= dump_node_label(F, n);
+ dump_node_ana_info(F, n);
fprintf(F, "\" ");
bad |= dump_node_info(F, n);
print_node_error(F, p);
- dump_node_vcgattr(F, n, bad);
+ dump_node_vcgattr(F, n, NULL, bad);
fprintf(F, "}\n");
dump_const_node_local(F, n);
#if DO_HEAPANALYSIS
- dump_chi_term(F, n);
- dump_state(F, n);
+ dump_irn_chi_term(F, n);
+ dump_irn_state(F, n);
#endif
}
-/* dump the edge to the block this node belongs to */
+/** dump the edge to the block this node belongs to */
static void
dump_ir_block_edge(FILE *F, ir_node *n) {
if (get_opt_dump_const_local() && is_constlike_node(n)) return;
if (is_no_Block(n)) {
ir_node *block = get_nodes_block(n);
- fprintf (F, "edge: { sourcename: \"");
- PRINT_NODEID(n);
- fprintf (F, "\" targetname: ");
- fprintf(F, "\""); PRINT_NODEID(block); fprintf(F, "\"");
- fprintf (F, " " BLOCK_EDGE_ATTR "}\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, "\"");
+ fprintf (F, " " BLOCK_EDGE_ATTR "}\n");
+ }
}
}
/* dump edges to our inputs */
static void
dump_ir_data_edges(FILE *F, ir_node *n) {
- int i, visited = get_irn_visited(n);
+ int i;
+ unsigned long visited = get_irn_visited(n);
if ((get_irn_op(n) == op_End) && (!dump_keepalive))
return;
ir_node * pred = get_irn_n(n, i);
assert(pred);
- if ((interprocedural_view && get_irn_visited(pred) < visited))
+ if ((get_interprocedural_view() && get_irn_visited(pred) < visited))
continue; /* pred not dumped */
if (dump_backedge_information_flag && is_backedge(n, i))
fprintf(F, "graph: { title: \"");
PRINT_NODEID(block);
fprintf(F, "\" label: \"");
- dump_node_opcode(F, block);
- fprintf (F, " %ld", get_irn_node_nr(block));
+ dump_node_label(F, block);
#if DO_HEAPANALYSIS
if (get_opt_dump_abstvals())
fprintf (F, " seqno: %d", (int)get_Block_seqno(block));
fprintf(F, "}\n");
dump_const_node_local(F, block);
#if DO_HEAPANALYSIS
- dump_chi_term(F, block);
+ dump_irn_chi_term(F, block);
#endif
fprintf(F, "\n");
}
} 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);
}
}
/** Dumps an irg as a graph.
* If interprocedural view edges can point to nodes out of this graph.
*/
-static void dump_graph(FILE *F, ir_graph *irg) {
+static void dump_graph_from_list(FILE *F, ir_graph *irg) {
fprintf(F, "graph: { title: \"");
PRINT_IRGID(irg);
/* Basic type and entity nodes and edges. */
/*******************************************************************/
-/* dumps the edges between nodes and their type or entity attributes. */
+/** dumps the edges between nodes and their type or entity attributes. */
static void dump_node2type_edges(ir_node *n, void *env)
{
FILE *F = env;
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))) {
+ 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);
}
case k_entity: {
entity *ent = (entity *)tore;
if (get_entity_owner(ent) == get_glob_type()) break;
- if (!is_method_type(get_entity_type(ent))) break; /* GL */
- if (env->dump_ent && is_class_type(get_entity_owner(ent))) {
+ if (!is_Method_type(get_entity_type(ent))) break; /* GL */
+ if (env->dump_ent && is_Class_type(get_entity_owner(ent))) {
/* The node */
dump_entity_node(F, ent, 0);
/* The edges */
/**
* dumps the VCG header
*/
-static INLINE void
-dump_vcg_header(FILE *F, const char *name, const char *orientation) {
+INLINE void dump_vcg_header(FILE *F, const char *name, const char *orientation) {
char *label;
if (edge_label) {
"classname 16: \"interblock Data\"\n"
"classname 2: \"Block\"\n"
"classname 13: \"Control Flow\"\n"
+ "classname 18: \"Exception Control Flow for Interval Analysis\"\n"
"classname 14: \"intrablock Memory\"\n"
"classname 17: \"interblock Memory\"\n"
"classname 15: \"Dominators\"\n"
"colorentry 123: 255 220 220\n"
"colorentry 124: 255 240 240\n"
"colorentry 125: 255 250 250\n"
- );
+ );
fprintf (F, "\n"); /* a separator */
}
* @param suffix1 first filename suffix
* @param suffix2 second filename suffix
*/
-static 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;
/* strncpy (fname, nm, len); */ /* copy the filename */
j = 0;
- for (i = 0; i < len; ++i) { /* replase '/' in the name: escape by @. */
+ for (i = 0; i < len; ++i) { /* replace '/' in the name: escape by @. */
if (nm[i] == '/') {
fname[j] = '@'; j++; fname[j] = '1'; j++;
} else if (nm[i] == '@') {
strcat (fname, suffix1); /* append file suffix */
strcat (fname, suffix2); /* append file suffix */
strcat (fname, ".vcg"); /* append the .vcg suffix */
- F = fopen (fname, "w"); /* open file for writing */
+
+ /* vcg really expect only a <CR> at end of line, so
+ * the "b"inary mode is what you mean (and even needed for Win32)
+ */
+ F = fopen (fname, "wb"); /* open file for writing */
if (!F) {
panic("cannot open %s for writing (%m)", fname); /* not reached */
}
* @param irg The graph to be dumped
* @param suffix filename suffix
*/
-static FILE *vcg_open_name (const char *name, const char *suffix) {
+FILE *vcg_open_name (const char *name, const char *suffix) {
FILE *F;
char *fname; /* filename to put the vcg information in */
int i, j, len = strlen(name);
fname = malloc (len * 2 + 5 + strlen(suffix));
/* strcpy (fname, name);*/ /* copy the filename */
j = 0;
- for (i = 0; i < len; ++i) { /* replase '/' in the name: escape by @. */
+ for (i = 0; i < len; ++i) { /* replace '/' in the name: escape by @. */
if (name[i] == '/') {
fname[j] = '@'; j++; fname[j] = '1'; j++;
} else if (name[i] == '@') {
fname[j] = '\0';
strcat (fname, suffix);
strcat (fname, ".vcg"); /* append the .vcg suffix */
- F = fopen (fname, "w"); /* open file for writing */
+
+ /* vcg really expect only a <CR> at end of line, so
+ * the "b"inary mode is what you mean (and even needed for Win32)
+ */
+ F = fopen (fname, "wb"); /* open file for writing */
if (!F) {
panic ("cannot open %s for writing (%m)", fname); /* not reached */
}
/**
* close the vcg file
*/
-static void
-vcg_close (FILE *F) {
+void vcg_close (FILE *F) {
dump_vcg_footer(F); /* print footer */
fclose (F); /* close vcg file */
}
/************************************************************************/
/************************************************************************/
-/* Dump ir graphs, differnt formats and additional information. */
+/* Dump ir graphs, different formats and additional information. */
/************************************************************************/
-/** Routine to dump a graph, blocks as conventional nodes.
- */
+/** Routine to dump a graph, blocks as conventional nodes. */
void
dump_ir_graph (ir_graph *irg, const char *suffix )
{
char *suffix1;
rem = current_ir_graph;
- if (strncmp(get_entity_name(get_irg_entity(irg)), dump_file_filter, strlen(dump_file_filter)) != 0) return;
+ if (strncmp(get_entity_name(get_irg_entity(irg)),
+ dump_file_filter, strlen(dump_file_filter)) != 0) return;
+
current_ir_graph = irg;
- if (interprocedural_view) suffix1 = "-pure-ip";
- else suffix1 = "-pure";
+ if (get_interprocedural_view()) suffix1 = "-pure-ip";
+ else suffix1 = "-pure";
f = vcg_open(irg, suffix, suffix1);
dump_vcg_header(f, get_irg_dump_name(irg), NULL);
/* dump the out edges in a separate walk */
if ((dump_out_edge_flag) && (get_irg_outs_state(irg) != outs_none)) {
- irg_out_walk(get_irg_start(irg), dump_out_edge, NULL, NULL);
+ irg_out_walk(get_irg_start(irg), dump_out_edge, NULL, f);
}
vcg_close(f);
if (strncmp(get_entity_name(get_irg_entity(irg)), dump_file_filter, strlen(dump_file_filter)) != 0)
return;
- if (interprocedural_view) suffix1 = "-ip";
- else suffix1 = "";
+ if (get_interprocedural_view()) suffix1 = "-ip";
+ else suffix1 = "";
f = vcg_open(irg, suffix, suffix1);
dump_vcg_header(f, get_irg_dump_name(irg), NULL);
for (i = 0; i < get_irp_n_irgs(); i++) {
ir_node **arr = ird_get_irg_link(get_irp_irg(i));
if (arr) {
- dump_graph(f, get_irp_irg(i));
+ dump_graph_from_list(f, get_irp_irg(i));
DEL_ARR_F(arr);
}
}
vcg_close(f);
}
-/** dumps a graph with type information
- */
+/** dumps a graph with type information */
void
dump_ir_graph_w_types (ir_graph *irg, const char *suffix)
{
current_ir_graph = irg;
- if (interprocedural_view) suffix1 = "-pure-wtypes-ip";
- else suffix1 = "-pure-wtypes";
+ if (get_interprocedural_view()) suffix1 = "-pure-wtypes-ip";
+ else suffix1 = "-pure-wtypes";
f = vcg_open(irg,suffix, suffix1);
dump_vcg_header(f, get_irg_dump_name(irg), NULL);
if (strncmp(get_entity_name(get_irg_entity(irg)), dump_file_filter, strlen(dump_file_filter)) != 0)
return;
- if (interprocedural_view) suffix1 = "-wtypes-ip";
- else suffix1 = "-wtypes";
+ if (get_interprocedural_view()) suffix1 = "-wtypes-ip";
+ else suffix1 = "-wtypes";
f = vcg_open(irg, suffix, suffix1);
dump_vcg_header(f, get_irg_dump_name(irg), NULL);
for (i = 0; i < get_irp_n_irgs(); i++) {
ir_node **arr = ird_get_irg_link(get_irp_irg(i));
if (arr) {
- dump_graph(f, get_irp_irg(i));
+ dump_graph_from_list(f, get_irp_irg(i));
DEL_ARR_F(arr);
}
}
PRINT_NODEID(block);
fprintf (F, "\" ");
fprintf(F, "info1:\"");
- if (dump_dominator_information_flag)
+ if (dump_dominator_information_flag) {
fprintf(F, "dom depth %d\n", get_Block_dom_depth(block));
+ fprintf(F, "tree pre num %d\n", get_Block_dom_tree_pre_num(block));
+ fprintf(F, "max subtree pre num %d\n", get_Block_dom_max_subtree_pre_num(block));
+ }
/* show arity and possible Bad predecessors of the block */
fprintf(F, "arity: %d\n", get_Block_n_cfgpreds(block));
for (fl = i = 0; i < get_Block_n_cfgpreds(block); ++i) {
ir_node *pred = get_Block_cfgpred(block, i);
if (is_Bad(pred)) {
- if (! fl)
- fprintf(F, "Bad pred at pos: ");
- fprintf(F, "%d ", i);
- fl = 1;
+ if (! fl)
+ fprintf(F, "Bad pred at pos: ");
+ fprintf(F, "%d ", i);
+ fl = 1;
}
}
if (fl)
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))) )
+ (block == get_irg_end_block(get_irn_irg(block))) )
fprintf(F, " color:blue ");
else if (fl)
fprintf(F, " color:yellow ");
FILE *f;
ir_graph *rem = current_ir_graph;
int ddif = dump_dominator_information_flag;
- int ipv = interprocedural_view;
+ int ipv = get_interprocedural_view();
/* if a filter is set, dump only the irg's that match the filter */
if (strncmp(get_entity_name(get_irg_entity(irg)), dump_file_filter, strlen(dump_file_filter)) != 0)
f = vcg_open(irg, suffix, "-cfg");
dump_vcg_header(f, get_irg_dump_name(irg), NULL);
- if (interprocedural_view) {
+ if (ipv) {
printf("Warning: dumping cfg not in interprocedural view!\n");
- interprocedural_view = 0;
+ set_interprocedural_view(false);
}
if (get_irg_dom_state(irg) != dom_consistent)
dump_node(f, get_irg_bad(irg));
dump_dominator_information_flag = ddif;
- interprocedural_view = ipv;
+ set_interprocedural_view(ipv);
vcg_close(f);
current_ir_graph = rem;
}
+
+static void descend_and_dump(FILE *F, ir_node *n, int depth, pset *mark_set) {
+ if (pset_find_ptr(mark_set, n)) return;
+
+ pset_insert_ptr(mark_set, n);
+
+ if (depth > 0) {
+ int i, start = is_Block(n) ? 0 : -1;
+ dump_whole_node(n, F);
+ for (i = start; i < get_irn_arity(n); ++i)
+ descend_and_dump(F, get_irn_n(n, i), depth-1, mark_set);
+ } else {
+ dump_node(F, n);
+ /* Don't dump edges to nodes further out. These might be edges to
+ nodes we already dumped, if there is a shorter path to these. */
+ }
+}
+
+static int subgraph_counter = 0;
+void dump_subgraph (ir_node *root, int depth, const char *suffix) {
+ FILE *F;
+ char buf[32];
+ pset *mark_set = pset_new_ptr(1);
+ sprintf(buf, "-subg_%03d", subgraph_counter++);
+ F = vcg_open(get_irn_irg(root), suffix, buf);
+ dump_vcg_header(F, get_irg_dump_name(get_irn_irg(root)), NULL);
+ descend_and_dump(F, root, depth, mark_set);
+ vcg_close(F);
+ del_pset(mark_set);
+}
+
+
static int weight_overall(int rec, int loop) {
return 2*rec + loop;
}
if (!max) {
color = 0;
} else {
+ int step;
+
/* if small, scale to the full color range. */
if (max < n_colors)
my = my * (n_colors/max);
- int step = 1 + (max / n_colors);
+ step = 1 + (max / n_colors);
color = my/step;
}
}
static int get_entity_color(entity *ent) {
- assert(get_entity_irg(ent));
ir_graph *irg = get_entity_irg(ent);
+ assert(irg);
- int rec_depth = get_irg_recursion_depth(irg);
- int loop_depth = get_irg_loop_depth(irg);
- int overall_depth = weight_overall(rec_depth, loop_depth);
+ {
+ int rec_depth = get_irg_recursion_depth(irg);
+ int loop_depth = get_irg_loop_depth(irg);
+ int overall_depth = weight_overall(rec_depth, loop_depth);
- int max_rec_depth = irp->max_callgraph_recursion_depth;
- int max_loop_depth = irp->max_callgraph_loop_depth;
- int max_overall_depth = weight_overall(max_rec_depth, max_loop_depth);
+ int max_rec_depth = irp->max_callgraph_recursion_depth;
+ int max_loop_depth = irp->max_callgraph_loop_depth;
+ int max_overall_depth = weight_overall(max_rec_depth, max_loop_depth);
- int my_rec_color = compute_color(rec_depth, max_rec_depth);
- int my_loop_color = compute_color(loop_depth, max_loop_depth);
- int my_overall_color = compute_color(overall_depth, max_overall_depth);;
+ /* int my_rec_color = compute_color(rec_depth, max_rec_depth); */
+ /* int my_loop_color = compute_color(loop_depth, max_loop_depth); */
+ int my_overall_color = compute_color(overall_depth, max_overall_depth);;
- return my_overall_color;
+ return my_overall_color;
+ }
}
void dump_callgraph(const char *suffix) {
void dump_all_cg_block_graph(const char *suffix) {
FILE *f;
int i;
- int rem_view = interprocedural_view;
- interprocedural_view = 1;
+ int rem_view = get_interprocedural_view();
+ set_interprocedural_view(true);
f = vcg_open_name("All_graphs", suffix);
dump_vcg_header(f, "All_graphs", NULL);
for (i = 0; i < get_irp_n_irgs(); i++) {
current_ir_graph = get_irp_irg(i);
assert(ird_get_irg_link(current_ir_graph));
- dump_graph(f, current_ir_graph);
+ dump_graph_from_list(f, current_ir_graph);
DEL_ARR_F(ird_get_irg_link(current_ir_graph));
}
vcg_close(f);
- interprocedural_view = rem_view;
+ set_interprocedural_view(rem_view);
}
-/***********************************************************************/
+/*---------------------------------------------------------------------*/
/* the following routines dumps type information without any ir nodes. */
-/***********************************************************************/
+/*---------------------------------------------------------------------*/
void
dump_type_graph (ir_graph *irg, const char *suffix)
/* walk over the blocks in the graph */
type_walk_irg(irg, dump_type_info, NULL, f);
/* The walker for the const code can be called several times for the
- same (sub) experssion. So that no nodes are dumped several times
+ same (sub) expression. So that no nodes are dumped several times
we decrease the visited flag of the corresponding graph after each
walk. So now increase it finally. */
inc_irg_visited(get_const_code_irg());
vcg_close(f);
}
-/***********************************************************************/
+/*---------------------------------------------------------------------*/
/* dumps all graphs with the graph-dumper passed. Possible dumpers: */
/* dump_ir_graph */
/* dump_ir_block_graph */
/* dump_cfg */
/* dump_type_graph */
/* dump_ir_graph_w_types */
-/***********************************************************************/
+/*---------------------------------------------------------------------*/
void dump_all_ir_graphs(dump_graph_func *dmp_grph, const char *suffix) {
int i, n_irgs = get_irp_n_irgs();
}
-/**********************************************************************************
+/*--------------------------------------------------------------------------------*
* Dumps a stand alone loop graph with firm nodes which belong to one loop node *
* packed together in one subgraph/box *
- **********************************************************************************/
+ *--------------------------------------------------------------------------------*/
void dump_loops_standalone(FILE *F, ir_loop *loop) {
int i = 0, loop_node_started = 0, son_number = 0, first = 0;
int bad = 0;
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;
- first = i;
+ /* 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;
+ first = i;
}
else
- fprintf(F, "\n");
-
- bad |= dump_node_opcode(F, n);
- bad |= dump_node_mode(F, n);
- bad |= dump_node_typeinfo(F, n);
- fprintf (F, " ");
- bad |= dump_node_nodeattr(F, n);
- fprintf (F, " %ld", get_irn_node_nr(n));
- if (is_Block(n)) fprintf (F, "\t ->%d", (int)get_irn_link(n));
+ fprintf(F, "\n");
+
+ bad |= 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;
assert(get_kind(son) == k_ir_graph);
+
/* We are a loop node -> Collect firm graphs */
- ir_graph *n = (ir_graph *)le.node;
+ n = (ir_graph *)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;
- first = i;
+ /* 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;
+ first = i;
}
else
- fprintf(F, "\n");
+ fprintf(F, "\n");
fprintf (F, " %s", get_irg_dump_name(n));
/* fprintf (F, " %s (depth %d)", get_irg_dump_name(n), n->callgraph_weighted_loop_depth); */
}
}
-/*******************************************************************************/
+/*-----------------------------------------------------------------------------*/
/* Dumps the firm nodes in the loop tree to a graph along with the loop nodes. */
-/*******************************************************************************/
+/*-----------------------------------------------------------------------------*/
void collect_nodeloop(FILE *F, ir_loop *loop, eset *loopnodes) {
int i, son_number = 0, node_number = 0;
projects / libfirm / blobdiff