#include "pset.h"
#if DO_HEAPANALYSIS
-void dump_irn_chi_term(FILE *FL, ir_node *n);
-void dump_irn_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 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;
}
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) {
+ 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));
+ fprintf(F, "[%s] ", get_type_name_ex(tp, &bad));
else
- fprintf(F, " []");
+ fprintf(F, "[] ");
}
}
return bad;
switch (get_irn_opcode(n)) {
case iro_Start:
if (false && get_interprocedural_view()) {
- fprintf (F, "%s", get_ent_dump_name(get_irg_entity(current_ir_graph)));
+ 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)));
+ 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));
+ 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)));
+ fprintf (F, "%s ", get_pnc_string(get_Confirm_cmp(n)));
break;
default:
return 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.
+ * 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)
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, n, con, bad);
n and blk. */
fprintf(F, "node: {title: \""); PRINT_CONSTBLKID(n, blk);
fprintf(F, "\" label: \"");
- bad |= dump_node_opcode(F, blk);
- bad |= dump_node_mode(F, blk);
- bad |= dump_node_typeinfo(F, blk);
- fprintf (F, " ");
- bad |= dump_node_nodeattr(F, blk);
- fprintf(F, " %ld", get_irn_node_nr(blk));
+ bad |= dump_node_label(F, blk);
fprintf(F, "\" ");
bad |= dump_node_info(F, blk);
dump_node_vcgattr(F, n, blk, bad);
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);
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, "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 */
}
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. */
rem = current_ir_graph;
if (strncmp(get_entity_name(get_irg_entity(irg)),
- dump_file_filter, strlen(dump_file_filter)) != 0) return;
+ dump_file_filter, strlen(dump_file_filter)) != 0) return;
current_ir_graph = irg;
if (get_interprocedural_view()) suffix1 = "-pure-ip";
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));
/* 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());
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));
+ 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 */
projects / libfirm / blobdiff