#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
/* basis for a color range for vcg */
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_typeinfo_type(n);
- if (tp != none_type)
+ if (tp != firm_none_type)
fprintf(F, " [%s]", get_type_name_ex(tp, &bad));
else
fprintf(F, " []");
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
}
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");
}
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 */
/* 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 */
}
/************************************************************************/
/************************************************************************/
-/* 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. */
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 (get_interprocedural_view()) suffix1 = "-pure-ip";
else suffix1 = "-pure";
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));
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;
}
/* 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());