X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firdump.c;h=7178dc09aff8ddb9e28123c8db2f1b5c4df288e0;hb=e02242afbe5184c315e6c8fc2aef8d0f32ad7e84;hp=fc5b4278b1c3ce2a7020cc3ef620b2d3dc678206;hpb=348085783f818d30cde284785fa299f8f109c0e5;p=libfirm diff --git a/ir/ir/irdump.c b/ir/ir/irdump.c index fc5b4278b..7178dc09a 100644 --- a/ir/ir/irdump.c +++ b/ir/ir/irdump.c @@ -9,27 +9,30 @@ * Copyright: (c) 1998-2003 Universität Karlsruhe * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. */ - - #ifdef HAVE_CONFIG_H -# include +#include "config.h" #endif +#ifdef HAVE_STRING_H #include +#endif +#ifdef HAVE_STDLIB_H #include +#endif #include +#include "firm_common_t.h" + #include "irnode_t.h" #include "irgraph_t.h" +#include "irprog_t.h" #include "entity_t.h" #include "irop_t.h" -#include "firm_common_t.h" -#include "irdump.h" +#include "irdump_t.h" #include "irgwalk.h" #include "typewalk.h" -#include "irprog.h" #include "tv_t.h" #include "type_or_entity.h" #include "irouts.h" @@ -43,91 +46,50 @@ #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; + +#define ERROR_TXT "" -static const char *get_mode_name_ex(ir_mode *mode, int *bad) +/** + * returns the name of a mode or 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 ""; + return ERROR_TXT; } -static const char *get_type_name_ex(type *tp, int *bad) +/** + * returns the name of a type or 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 ""; + 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; @@ -140,6 +102,10 @@ static void print_type_type_edge(FILE *F, type *S, type *T, const char *fmt, ... 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; @@ -152,6 +118,10 @@ static void print_type_ent_edge(FILE *F, type *T, entity *E, const char *fmt, .. 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; @@ -168,6 +138,10 @@ static void print_ent_ent_edge(FILE *F, entity *E, entity *T, int backedge, cons 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; @@ -180,6 +154,10 @@ static void print_ent_type_edge(FILE *F, entity *E, type *T, const char *fmt, .. 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; @@ -192,6 +170,10 @@ static void print_node_type_edge(FILE *F, const ir_node *N, type *T, const char 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; @@ -205,6 +187,10 @@ static void print_node_ent_edge(FILE *F, const ir_node *N, entity *E, const char 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; @@ -217,6 +203,10 @@ static void print_ent_node_edge(FILE *F, entity *E, const ir_node *N, const char 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; @@ -229,35 +219,34 @@ static void print_enum_item_edge(FILE *F, type *E, int item, const char *fmt, .. va_end(ap); } -/*******************************************************************/ +/*-----------------------------------------------------------------*/ /* global and ahead declarations */ -/*******************************************************************/ - -/* A suffix to manipulate the file name. */ -char *dump_file_suffix = ""; - -char *dump_file_filter = ""; +/*-----------------------------------------------------------------*/ 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; @@ -266,12 +255,18 @@ void *ird_get_irn_link(ir_node *n) { 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; @@ -280,60 +275,87 @@ void *ird_get_irg_link(ir_graph *irg) { 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_op_pinned(get_irn_op(n)) == floats) && - (get_irg_pinned(current_ir_graph) == floats)); -} - -static const char *get_ent_dump_name(entity *ent) { - if (! ent) +/** + * 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) return ""; /* 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); } -static const char *get_irg_dump_name(ir_graph *irg) { +/* 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_ent(irg); + 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 pinned, - * Bad and Unknown into a flexible array in link field of + * Collects all blocks, nodes not op_pin_state_pinned, + * 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; @@ -343,12 +365,14 @@ static ir_node ** construct_block_lists(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); @@ -358,13 +382,16 @@ static ir_node ** construct_block_lists(ir_graph *irg) { /* flags to steer output */ /*******************************************************************/ -/* 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 */ +/** Dump only irgs with names start with this string */ +const char *dump_file_filter = ""; + +/** 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; @@ -373,7 +400,16 @@ int dump_const_local = 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) @@ -382,6 +418,11 @@ INLINE bool get_opt_dump_const_local(void) { return false; } +void only_dump_method_with_name(ident *name) { + dump_file_filter = get_id_str(name); +} + + /* To turn off display of edge labels. Edge labels offen cause xvcg to abort with a segmentation fault. */ void turn_off_edge_labels(void) { @@ -392,8 +433,8 @@ void dump_consts_local(bool b) { 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) { @@ -404,20 +445,16 @@ bool get_opt_dump_keepalive_edges(void) { return dump_keepalive; } -void dump_out_edges(void) { - dump_out_edge_flag = 1; +void dump_out_edges(bool b) { + dump_out_edge_flag = b; } -void dump_dominator_information(void) { - dump_dominator_information_flag = 1; +void dump_dominator_information(bool b) { + dump_dominator_information_flag = b; } -void dump_loop_information(void) { - dump_loop_information_flag = 1; -} - -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) { @@ -428,7 +465,7 @@ 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; } @@ -436,11 +473,14 @@ void dump_pointer_values_to_info(bool b) { opt_dump_pointer_values_to_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; @@ -475,8 +515,10 @@ dump_node_opcode(FILE *F, ir_node *n) } break; case iro_Filter: { - if (!interprocedural_view) fprintf(F, "Proj'"); - else fprintf(F, "%s", get_irn_opname(n)); + if (!get_interprocedural_view()) + fprintf(F, "Proj'"); + else + goto default_case; } break; case iro_Proj: { @@ -491,16 +533,34 @@ dump_node_opcode(FILE *F, ir_node *n) * fprintf (F, "Arg"); */ else - fprintf (F, "%s", get_irn_opname(n)); + goto default_case; } break; - - case iro_Start: { - if (interprocedural_view) { - fprintf(F, "%s %s", get_irn_opname(n), get_ent_dump_name(get_irg_ent(get_irn_irg(n)))); + case iro_Start: + case iro_End: + case iro_EndExcept: + case iro_EndReg: { + if (get_interprocedural_view()) { + fprintf(F, "%s %s", get_irn_opname(n), get_ent_dump_name(get_irg_entity(get_irn_irg(n)))); break; - } - } /* fall through */ + } else + goto default_case; + } + case iro_CallBegin: { + ir_node *addr = get_CallBegin_ptr(n); + entity *ent = NULL; + if (get_irn_op(addr) == op_Sel) + ent = get_Sel_entity(addr); + else if ((get_irn_op(addr) == op_SymConst) && (get_SymConst_kind(addr) == symconst_addr_ent)) + ent = get_SymConst_entity(addr); + fprintf (F, "%s", get_irn_opname(n)); + if (ent) fprintf (F, " %s", get_entity_name(ent)); + break; + } + case iro_Load: + fprintf (F, "%s[%s]", get_irn_opname(n), get_mode_name_ex(get_Load_mode(n), &bad)); + break; +default_case: default: { fprintf (F, "%s", get_irn_opname(n)); } @@ -509,54 +569,60 @@ dump_node_opcode(FILE *F, ir_node *n) 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) { int bad = 0; + opcode iro = get_irn_opcode(n); + + switch (iro) { + case iro_SymConst: + case iro_Sel: + case iro_End: + case iro_Return: + case iro_Free: + case iro_Sync: + case iro_Jmp: + case iro_NoMem: + break; + default: { + ir_mode *mode = get_irn_mode(n); - switch (get_irn_opcode(n)) { - case iro_Phi: - case iro_Const: - case iro_Id: - case iro_Proj: - case iro_Filter: - case iro_Conv: - case iro_Tuple: - case iro_Add: - case iro_Sub: - case iro_Mul: - case iro_And: - case iro_Or: - case iro_Eor: - case iro_Shl: - case iro_Shr: - case iro_Abs: - case iro_Cmp: - case iro_Confirm: - fprintf(F, "%s", get_mode_name_ex(get_irn_mode(n), &bad)); - break; - default: - ; + if (mode && 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; } +/** + * 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) { @@ -564,29 +630,29 @@ 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_ent(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: ; @@ -595,12 +661,41 @@ dump_node_nodeattr(FILE *F, ir_node *n) 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: @@ -611,7 +706,10 @@ static INLINE void dump_node_vcgattr(FILE *F, ir_node *n, int bad) 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"); @@ -629,150 +727,29 @@ static INLINE void dump_node_vcgattr(FILE *F, ir_node *n, int bad) 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))); - - 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_ent(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)); - } 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, "\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_ent(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_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; - 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; @@ -783,7 +760,7 @@ static void dump_const_node_local(FILE *F, ir_node *n) { 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(current_ir_graph) - 1); } } @@ -797,66 +774,99 @@ static void dump_const_node_local(FILE *F, ir_node *n) { 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)) { - fprintf (F, "edge: { sourcename: \""); - PRINT_NODEID(n); - fprintf (F, "\" targetname: \""); - PRINT_NODEID(get_nodes_block(n)); - fprintf (F, "\" " BLOCK_EDGE_ATTR "}\n"); + ir_node *block = get_nodes_block(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"); + } } } @@ -1004,7 +1014,8 @@ print_edge_vcgattr(FILE *F, ir_node *from, int to) { /* 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; @@ -1013,7 +1024,7 @@ dump_ir_data_edges(FILE *F, ir_node *n) { 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)) @@ -1090,8 +1101,7 @@ dump_whole_block(FILE *F, ir_node *block) { 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)); @@ -1112,13 +1122,13 @@ dump_whole_block(FILE *F, ir_node *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"); } /** dumps a graph block-wise. Expects all blockless nodes in arr in irgs link. - * The outermost nodes: blocks and nodes not pinned, Bad, Unknown. */ + * The outermost nodes: blocks and nodes not op_pin_state_pinned, Bad, Unknown. */ static void dump_block_graph(FILE *F, ir_graph *irg) { int i; @@ -1135,11 +1145,15 @@ dump_block_graph(FILE *F, ir_graph *irg) { } 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); } } - if (dump_loop_information_flag) dump_loop_nodes_into_graph(F, irg); + if (dump_loop_information_flag && (get_irg_loopinfo_state(irg) & loopinfo_valid)) + dump_loop_nodes_into_graph(F, irg); current_ir_graph = rem; } @@ -1147,12 +1161,12 @@ dump_block_graph(FILE *F, ir_graph *irg) { /** 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); fprintf(F, "\" label: \"%s\" status:clustered color:white \n", - get_ent_dump_name(get_irg_ent(irg))); + get_ent_dump_name(get_irg_entity(irg))); dump_block_graph(F, irg); @@ -1164,7 +1178,7 @@ static void dump_graph(FILE *F, ir_graph *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; @@ -1305,54 +1319,21 @@ static int print_type_node(FILE *F, type *tp) } #define X(a) case a: fprintf(F, #a); break -void dump_entity_node(FILE *F, entity *ent) +void dump_entity_node(FILE *F, entity *ent, int color) { fprintf (F, "node: {title: \""); PRINT_ENTID(ent); fprintf(F, "\""); fprintf (F, DEFAULT_TYPE_ATTRIBUTE); fprintf (F, "label: "); - fprintf (F, "\"ent %s\" " ENTITY_NODE_ATTR , get_ent_dump_name(ent)); - fprintf (F, "\n info1: \"\nid: "); PRINT_ENTID(ent); - - fprintf (F, "\nallocation: "); - switch (get_entity_allocation(ent)) { - X(allocation_dynamic); - X(allocation_automatic); - X(allocation_static); - X(allocation_parameter); - } - - fprintf (F, "\nvisibility: "); - switch (get_entity_visibility(ent)) { - X(visibility_local); - X(visibility_external_visible); - X(visibility_external_allocated); - } - - fprintf (F, "\nvariability: "); - switch (get_entity_variability(ent)) { - X(variability_uninitialized); - X(variability_initialized); - X(variability_part_constant); - X(variability_constant); - } + fprintf (F, "\"ent %s\" ", get_ent_dump_name(ent)); + if (color) + fprintf(F, "color: %d", color); + else + fprintf (F, ENTITY_NODE_ATTR); + fprintf (F, "\n info1: \""); - fprintf (F, "\nvolatility: "); - switch (get_entity_volatility(ent)) { - X(volatility_non_volatile); - X(volatility_is_volatile); - } + dump_entity_to_file(F, ent, dump_verbosity_entattrs | dump_verbosity_entconsts); - fprintf(F, "\npeculiarity: %s", get_peculiarity_string(get_entity_peculiarity(ent))); - fprintf(F, "\nname: %s\nld_name: %s", - get_entity_name(ent), ent->ld_name ? get_entity_ld_name(ent) : "no yet set"); - fprintf(F, "\noffset(bits): %d", get_entity_offset_bits(ent)); - if (is_method_type(get_entity_type(ent))) { - if (get_entity_irg(ent)) /* can be null */ - { fprintf (F, "\nirg = "); PRINT_IRGID(get_entity_irg(ent)); } - else - { fprintf (F, "\nirg = NULL"); } - } fprintf(F, "\"\n}\n"); } #undef X @@ -1386,13 +1367,13 @@ dump_type_info(type_or_ent *tore, void *env) { entity *ent = (entity *)tore; ir_node *value; /* The node */ - dump_entity_node(F, ent); + dump_entity_node(F, ent, 0); /* 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))) { + 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); } @@ -1512,13 +1493,14 @@ dump_class_hierarchy_node (type_or_ent *tore, void *ctx) { case k_entity: { entity *ent = (entity *)tore; if (get_entity_owner(ent) == get_glob_type()) break; - 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); + dump_entity_node(F, ent, 0); /* 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_ent_ent_edge(F, get_entity_overwrites(ent, i), ent, 0, ENT_OVERWRITES_EDGE_ATTR); } } break; /* case k_entity */ case k_type: @@ -1646,8 +1628,7 @@ void dump_loop_nodes_into_graph(FILE *F, ir_graph *irg) { /** * 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) { @@ -1670,6 +1651,7 @@ dump_vcg_header(FILE *F, const char *name, const char *orientation) { "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" @@ -1687,6 +1669,39 @@ dump_vcg_header(FILE *F, const char *name, const char *orientation) { "infoname 2: \"Verification errors\"\n", name, label, orientation); + /* don't use all, the range is too whith/black. */ + n_colors = 18; + base_color = 105; + fprintf (F, + "colorentry 100: 0 0 0\n" + "colorentry 101: 20 0 0\n" + "colorentry 102: 40 0 0\n" + "colorentry 103: 60 0 0\n" + "colorentry 104: 80 0 0\n" + "colorentry 105: 100 0 0\n" + "colorentry 106: 120 0 0\n" + "colorentry 107: 140 0 0\n" + "colorentry 108: 150 0 0\n" + "colorentry 109: 180 0 0\n" + "colorentry 110: 200 0 0\n" + "colorentry 111: 220 0 0\n" + "colorentry 112: 240 0 0\n" + "colorentry 113: 255 0 0\n" + "colorentry 113: 255 20 20\n" + "colorentry 114: 255 40 40\n" + "colorentry 115: 255 60 60\n" + "colorentry 116: 255 80 80\n" + "colorentry 117: 255 100 100\n" + "colorentry 118: 255 120 120\n" + "colorentry 119: 255 140 140\n" + "colorentry 120: 255 150 150\n" + "colorentry 121: 255 180 180\n" + "colorentry 122: 255 200 200\n" + "colorentry 123: 255 220 220\n" + "colorentry 124: 255 240 240\n" + "colorentry 125: 255 250 250\n" + ); + fprintf (F, "\n"); /* a separator */ } @@ -1697,7 +1712,7 @@ dump_vcg_header(FILE *F, const char *name, const char *orientation) { * @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; @@ -1711,7 +1726,7 @@ static FILE *vcg_open (ir_graph *irg, const char * suffix1, const char *suffix2) /* 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] == '@') { @@ -1724,7 +1739,11 @@ static FILE *vcg_open (ir_graph *irg, const char * suffix1, const char *suffix2) 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 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 */ } @@ -1739,7 +1758,7 @@ static FILE *vcg_open (ir_graph *irg, const char * suffix1, const char *suffix2) * @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); @@ -1750,7 +1769,7 @@ static FILE *vcg_open_name (const char *name, const char *suffix) { 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] == '@') { @@ -1762,7 +1781,11 @@ static FILE *vcg_open_name (const char *name, const char *suffix) { 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 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 */ } @@ -1781,8 +1804,7 @@ static INLINE void dump_vcg_footer (FILE *F) { /** * 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 */ } @@ -1794,27 +1816,25 @@ vcg_close (FILE *F) { /************************************************************************/ /************************************************************************/ -/* 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) +dump_ir_graph (ir_graph *irg, const char *suffix ) { FILE *f; ir_graph *rem; - char *suffix; + char *suffix1; rem = current_ir_graph; - /* if a filter is set, dump only the irg's that match the filter */ - if (strncmp(get_entity_name(get_irg_ent(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) suffix = "-pure-ip"; - else suffix = "-pure"; - f = vcg_open(irg, dump_file_suffix, suffix); + 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); /* walk over the graph */ @@ -1822,7 +1842,7 @@ dump_ir_graph (ir_graph *irg) irg_walk(get_irg_end(irg), NULL, dump_whole_node, f); /* dump the out edges in a separate walk */ - if ((dump_out_edge_flag) && (get_irg_outs_state(irg) != no_outs)) { + if ((dump_out_edge_flag) && (get_irg_outs_state(irg) != outs_none)) { irg_out_walk(get_irg_start(irg), dump_out_edge, NULL, f); } @@ -1833,19 +1853,18 @@ dump_ir_graph (ir_graph *irg) void -dump_ir_block_graph (ir_graph *irg) +dump_ir_block_graph (ir_graph *irg, const char *suffix) { FILE *f; int i; - char *suffix; + char *suffix1; - /* if a filter is set, dump only the irg's that match the filter */ - if (strncmp(get_entity_name(get_irg_ent(irg)), dump_file_filter, strlen(dump_file_filter)) != 0) + if (strncmp(get_entity_name(get_irg_entity(irg)), dump_file_filter, strlen(dump_file_filter)) != 0) return; - if (interprocedural_view) suffix = "-ip"; - else suffix = ""; - f = vcg_open(irg, dump_file_suffix, suffix); + if (get_interprocedural_view()) suffix1 = "-ip"; + else suffix1 = ""; + f = vcg_open(irg, suffix, suffix1); dump_vcg_header(f, get_irg_dump_name(irg), NULL); construct_block_lists(irg); @@ -1853,7 +1872,7 @@ dump_ir_block_graph (ir_graph *irg) 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); } } @@ -1861,24 +1880,23 @@ dump_ir_block_graph (ir_graph *irg) vcg_close(f); } -/** dumps a graph with type information - */ +/** dumps a graph with type information */ void -dump_ir_graph_w_types (ir_graph *irg) +dump_ir_graph_w_types (ir_graph *irg, const char *suffix) { FILE *f; ir_graph *rem = current_ir_graph; - char *suffix; + char *suffix1; /* if a filter is set, dump only the irg's that match the filter */ - if (strncmp(get_irg_dump_name(irg), dump_file_filter, strlen(dump_file_filter)) != 0) + 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) suffix = "-pure-wtypes-ip"; - else suffix = "-pure-wtypes"; - f = vcg_open(irg, dump_file_suffix, suffix); + 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); /* dump common ir graph */ @@ -1894,20 +1912,20 @@ dump_ir_graph_w_types (ir_graph *irg) } void -dump_ir_block_graph_w_types (ir_graph *irg) +dump_ir_block_graph_w_types (ir_graph *irg, const char *suffix) { FILE *f; int i; - char *suffix; + char *suffix1; ir_graph *rem = current_ir_graph; /* if a filter is set, dump only the irg's that match the filter */ - if (strncmp(get_irg_dump_name(irg), dump_file_filter, strlen(dump_file_filter)) != 0) + if (strncmp(get_entity_name(get_irg_entity(irg)), dump_file_filter, strlen(dump_file_filter)) != 0) return; - if (interprocedural_view) suffix = "-wtypes-ip"; - else suffix = "-wtypes"; - f = vcg_open(irg, dump_file_suffix, suffix); + 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); /* dump common blocked ir graph */ @@ -1916,7 +1934,7 @@ dump_ir_block_graph_w_types (ir_graph *irg) 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); } } @@ -1933,34 +1951,67 @@ dump_ir_block_graph_w_types (ir_graph *irg) vcg_close(f); } -/***********************************************************************/ +/*---------------------------------------------------------------------*/ /* The following routines dump a control flow graph. */ -/***********************************************************************/ +/*---------------------------------------------------------------------*/ static void dump_block_to_cfg(ir_node *block, void *env) { FILE *F = env; - int i; + int i, fl; ir_node *pred; if (is_Block(block)) { /* This is a block. Dump a node for the block. */ fprintf (F, "node: {title: \""); PRINT_NODEID(block); - fprintf (F, "\" label: \"%s ", get_op_name(get_irn_op(block))); + fprintf (F, "\" label: \""); + if (block == get_irg_start_block(get_irn_irg(block))) + fprintf(F, "Start "); + if (block == get_irg_end_block(get_irn_irg(block))) + fprintf(F, "End "); + + fprintf (F, "%s ", get_op_name(get_irn_op(block))); PRINT_NODEID(block); fprintf (F, "\" "); - if (dump_dominator_information_flag) - fprintf(F, "info1:dom depth %d", get_Block_dom_depth(block)); + fprintf(F, "info1:\""); + 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, "\n"); + + 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))) ) + fprintf(F, " color:blue "); + else if (fl) + fprintf(F, " color:yellow "); + 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) { - pred = get_nodes_block(skip_Proj(get_Block_cfgpred(block, i))); - fprintf (F, "edge: { sourcename: \""); - PRINT_NODEID(block); - fprintf (F, "\" targetname: \""); - PRINT_NODEID(pred); - fprintf (F, "\"}\n"); + pred = get_nodes_block(skip_Proj(get_Block_cfgpred(block, i))); + fprintf (F, "edge: { sourcename: \""); + PRINT_NODEID(block); + fprintf (F, "\" targetname: \""); + PRINT_NODEID(pred); + fprintf (F, "\"}\n"); } /* Dump dominator edge */ @@ -1976,25 +2027,25 @@ dump_block_to_cfg(ir_node *block, void *env) { } void -dump_cfg (ir_graph *irg) +dump_cfg (ir_graph *irg, const char *suffix) { 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_irg_dump_name(irg), dump_file_filter, strlen(dump_file_filter)) != 0) + if (strncmp(get_entity_name(get_irg_entity(irg)), dump_file_filter, strlen(dump_file_filter)) != 0) return; current_ir_graph = irg; - f = vcg_open(irg, dump_file_suffix, "-cfg"); + 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) @@ -2005,49 +2056,129 @@ dump_cfg (ir_graph *irg) 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. */ + } +} -void dump_callgraph(char *filesuffix) { +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; +} + +static int compute_color (int my, int max) { + int color; + if (!max) { + color = 0; + } else { + int step; + + /* if small, scale to the full color range. */ + if (max < n_colors) + my = my * (n_colors/max); + + step = 1 + (max / n_colors); + + color = my/step; + } + return base_color + n_colors - color; +} + +static int get_entity_color(entity *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 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);; + + return my_overall_color; + } +} + +void dump_callgraph(const char *suffix) { FILE *F; int i, n_irgs = get_irp_n_irgs(); + int rem = edge_label; + edge_label = 1; + //ident *prefix = new_id_from_str("java/"); - F = vcg_open_name("Callgraph", filesuffix); + F = vcg_open_name("Callgraph", suffix); dump_vcg_header(F, "Callgraph", NULL); for (i = 0; i < n_irgs; ++i) { ir_graph *irg = get_irp_irg(i); - entity *ent = get_irg_ent(irg); + entity *ent = get_irg_entity(irg); int j, n_callees = get_irg_n_callees(irg); - dump_entity_node(F, ent); + /* Do not dump runtime system. */ + //if (id_is_prefix(prefix, get_entity_ld_ident(ent))) continue; + + dump_entity_node(F, ent, get_entity_color(ent)); for (j = 0; j < n_callees; ++j) { 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\" color:red" : - "label:\"calls\""; - print_ent_ent_edge(F, ent, c, be, attr); + "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), get_entity_color(ent)); } } + edge_label = rem; vcg_close(F); } - /* Dump all irgs in interprocedural view to a single file. */ -void dump_all_cg_block_graph(void) { +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", dump_file_suffix); + f = vcg_open_name("All_graphs", suffix); dump_vcg_header(f, "All_graphs", NULL); /* collect nodes in all irgs reachable in call graph*/ @@ -2060,37 +2191,37 @@ void dump_all_cg_block_graph(void) { 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) +dump_type_graph (ir_graph *irg, const char *suffix) { FILE *f; ir_graph *rem; rem = current_ir_graph; /* if a filter is set, dump only the irg's that match the filter */ - if (strncmp(get_irg_dump_name(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; - f = vcg_open(irg, dump_file_suffix, "-type"); + f = vcg_open(irg, suffix, "-type"); dump_vcg_header(f, get_irg_dump_name(irg), NULL); /* 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()); @@ -2100,9 +2231,9 @@ dump_type_graph (ir_graph *irg) } void -dump_all_types (void) +dump_all_types (const char *suffix) { - FILE *f = vcg_open_name("All_types", dump_file_suffix); + FILE *f = vcg_open_name("All_types", suffix); dump_vcg_header(f, "All_types", NULL); type_walk(dump_type_info, NULL, f); inc_irg_visited(get_const_code_irg()); @@ -2110,9 +2241,9 @@ dump_all_types (void) } void -dump_class_hierarchy (bool entities) +dump_class_hierarchy (bool entities, const char *suffix) { - FILE *f = vcg_open_name("class_hierarchy", dump_file_suffix); + FILE *f = vcg_open_name("class_hierarchy", suffix); h_env_t env; env.f = f; @@ -2125,32 +2256,30 @@ dump_class_hierarchy (bool entities) 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) { - int i; - for (i=0; i < get_irp_n_irgs(); i++) { - dmp_grph(get_irp_irg(i)); +void dump_all_ir_graphs(dump_graph_func *dmp_grph, const char *suffix) { + int i, n_irgs = get_irp_n_irgs(); + for (i = 0; i < n_irgs; ++i) { + dmp_grph(get_irp_irg(i), suffix); } } -/********************************************************************************** - * Dumps a stand alone loop graph with firm nodes which belong to one loop nodes * - * packed together in one subgraph * - **********************************************************************************/ - - +/*--------------------------------------------------------------------------------* + * 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, first = 0; + int i = 0, loop_node_started = 0, son_number = 0, first = 0; loop_element le; ir_loop *son = NULL; @@ -2175,51 +2304,46 @@ void dump_loops_standalone(FILE *F, ir_loop *loop) { fprintf (F, "-%d-nodes\" label:\"%d...%d\"}\n", first, first, i-1); loop_node_started = 0; } - else if (get_kind(son) == k_ir_node) { - /* We are a loop node -> Collect firm nodes */ - - ir_node *n = le.node; - 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; - } - 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 CALLGRAPH_LOOP_TREE - else { - assert(get_kind(son) == k_ir_graph); - /* We are a loop node -> Collect firm graphs */ - - ir_graph *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; - } - else - fprintf(F, "\n"); + dump_loop_son_edge(F, loop, son_number++); + dump_loops_standalone(F, son); + } else if (get_kind(son) == k_ir_node) { + /* We are a loop node -> Collect firm nodes */ + + ir_node *n = le.node; + int bad = 0; - fprintf (F, " %s", get_irg_dump_name(n)); + 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; } -#endif + else + 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 */ + 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; + } + else + 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); */ } } @@ -2234,7 +2358,7 @@ void dump_loops_standalone(FILE *F, ir_loop *loop) { } } -void dump_loop_tree(ir_graph *irg, char *suffix) +void dump_loop_tree(ir_graph *irg, const char *suffix) { FILE *f; ir_graph *rem = current_ir_graph; @@ -2242,7 +2366,7 @@ void dump_loop_tree(ir_graph *irg, char *suffix) edge_label = 1; /* if a filter is set, dump only the irg's that match the filter */ - if (strncmp(get_irg_dump_name(irg), dump_file_filter, strlen(dump_file_filter)) != 0) + if (strncmp(get_entity_name(get_irg_entity(irg)), dump_file_filter, strlen(dump_file_filter)) != 0) return; current_ir_graph = irg; @@ -2258,20 +2382,18 @@ void dump_loop_tree(ir_graph *irg, char *suffix) current_ir_graph = rem; } -#if CALLGRAPH_LOOP_TREE -/* works, but the tree is meaningless. */ -void dump_callgraph_loop_tree(ir_loop *l, char *suffix) { - vcg_open_name("callgraph_looptree", suffix); - dump_vcg_header("callgraph_looptree", "top_to_bottom"); - dump_loops_standalone(l); - vcg_close(); +void dump_callgraph_loop_tree(const char *suffix) { + FILE *F; + F = vcg_open_name("Callgraph_looptree", suffix); + dump_vcg_header(F, "callgraph looptree", "top_to_bottom"); + dump_loops_standalone(F, irp->outermost_cg_loop); + vcg_close(F); } -#endif -/*******************************************************************************/ +/*-----------------------------------------------------------------------------*/ /* 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; @@ -2315,7 +2437,7 @@ void collect_nodeloop_external_nodes(ir_loop *loop, eset *loopnodes, eset *extno } } -void dump_loop(ir_loop *l, char *suffix) { +void dump_loop(ir_loop *l, const char *suffix) { FILE *F; char name[50]; eset *loopnodes = eset_create();