X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firdump.c;h=7f1ccd22c2316851a6e07b3e6c3f0d705e01e83a;hb=cb91bddc9cacdab7c28e4336847bd3dc248aa549;hp=3f25a2dadcd1872a5070aae9a87a1a6e68dafc5a;hpb=dddcc630819f338c3b45e2bc646233e6872d5bb6;p=libfirm diff --git a/ir/ir/irdump.c b/ir/ir/irdump.c index 3f25a2dad..7f1ccd22c 100644 --- a/ir/ir/irdump.c +++ b/ir/ir/irdump.c @@ -11,25 +11,22 @@ */ -#ifdef HAVE_CONFIG_H -# include -#endif - #include #include #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 "irgwalk.h" #include "typewalk.h" -#include "irprog.h" #include "tv_t.h" #include "type_or_entity.h" #include "irouts.h" @@ -112,6 +109,11 @@ SeqNo get_Block_seqno(ir_node *n); #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) { if (is_mode(mode)) @@ -233,10 +235,6 @@ static void print_enum_item_edge(FILE *F, type *E, int item, const char *fmt, .. /* global and ahead declarations */ /*******************************************************************/ -/* A suffix to manipulate the file name. */ - -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); @@ -294,7 +292,7 @@ static int node_floats(ir_node *n) { (get_irg_pinned(current_ir_graph) == op_pin_state_floats)); } -static const char *get_ent_dump_name(entity *ent) { +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! */ @@ -302,7 +300,7 @@ static const char *get_ent_dump_name(entity *ent) { return get_id_str(ent->name); } -static const char *get_irg_dump_name(ir_graph *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); @@ -357,6 +355,8 @@ static ir_node ** construct_block_lists(ir_graph *irg) { /* flags to steer output */ /*******************************************************************/ +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 */ @@ -381,6 +381,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) { @@ -435,9 +440,9 @@ 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_node_opcode(FILE *F, ir_node *n) @@ -475,7 +480,7 @@ dump_node_opcode(FILE *F, ir_node *n) case iro_Filter: { if (!interprocedural_view) fprintf(F, "Proj'"); - else fprintf(F, "%s", get_irn_opname(n)); + else goto default_case; } break; case iro_Proj: { @@ -490,16 +495,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: { + case iro_Start: + case iro_End: + case iro_EndExcept: + case iro_EndReg: { if (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)); } @@ -643,6 +666,28 @@ static INLINE int dump_node_info(FILE *F, ir_node *n) if (irg != get_const_code_irg()) fprintf (F, "irg: %s\n", get_ent_dump_name(get_irg_entity(irg))); + if (get_op_pinned(get_irn_op(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) || @@ -670,6 +715,16 @@ static INLINE int dump_node_info(FILE *F, ir_node *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)); @@ -699,11 +754,11 @@ static INLINE int dump_node_info(FILE *F, ir_node *n) 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))); - } + 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; @@ -733,23 +788,47 @@ static INLINE int dump_node_info(FILE *F, ir_node *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)); + 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), + 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: ; } @@ -782,7 +861,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); } } @@ -851,11 +930,13 @@ 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: \""); - PRINT_NODEID(get_nodes_block(n)); - fprintf (F, "\" " BLOCK_EDGE_ATTR "}\n"); + fprintf (F, "\" targetname: "); + fprintf(F, "\""); PRINT_NODEID(block); fprintf(F, "\""); + fprintf (F, " " BLOCK_EDGE_ATTR "}\n"); } } @@ -1138,7 +1219,8 @@ dump_block_graph(FILE *F, ir_graph *irg) { } } - 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; } @@ -1304,54 +1386,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 @@ -1385,7 +1434,7 @@ 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\" " @@ -1511,13 +1560,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 (!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: @@ -1686,6 +1736,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 */ } @@ -1799,14 +1882,14 @@ vcg_close (FILE *F) { /** Routine to dump a graph, blocks as conventional nodes. */ void -dump_ir_graph (ir_graph *irg, char *suffix ) +dump_ir_graph (ir_graph *irg, const char *suffix ) { FILE *f; ir_graph *rem; 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"; @@ -1829,13 +1912,15 @@ dump_ir_graph (ir_graph *irg, char *suffix ) void -dump_ir_block_graph (ir_graph *irg, char *suffix) +dump_ir_block_graph (ir_graph *irg, const char *suffix) { FILE *f; int i; char *suffix1; - 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; + if (interprocedural_view) suffix1 = "-ip"; else suffix1 = ""; f = vcg_open(irg, suffix, suffix1); @@ -1857,14 +1942,14 @@ dump_ir_block_graph (ir_graph *irg, char *suffix) /** dumps a graph with type information */ void -dump_ir_graph_w_types (ir_graph *irg, char *suffix) +dump_ir_graph_w_types (ir_graph *irg, const char *suffix) { FILE *f; ir_graph *rem = current_ir_graph; 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; @@ -1887,7 +1972,7 @@ dump_ir_graph_w_types (ir_graph *irg, char *suffix) } void -dump_ir_block_graph_w_types (ir_graph *irg, char *suffix) +dump_ir_block_graph_w_types (ir_graph *irg, const char *suffix) { FILE *f; int i; @@ -1895,7 +1980,7 @@ dump_ir_block_graph_w_types (ir_graph *irg, char *suffix) 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) suffix1 = "-wtypes-ip"; @@ -1926,34 +2011,64 @@ dump_ir_block_graph_w_types (ir_graph *irg, char *suffix) 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, "\" "); + fprintf(F, "info1:\""); if (dump_dominator_information_flag) - fprintf(F, "info1:dom depth %d", get_Block_dom_depth(block)); + fprintf(F, "dom depth %d\n", get_Block_dom_depth(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 */ @@ -1969,7 +2084,7 @@ dump_block_to_cfg(ir_node *block, void *env) { } void -dump_cfg (ir_graph *irg, char *suffix) +dump_cfg (ir_graph *irg, const char *suffix) { FILE *f; ir_graph *rem = current_ir_graph; @@ -1977,7 +2092,7 @@ dump_cfg (ir_graph *irg, char *suffix) int ipv = 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; @@ -2003,13 +2118,53 @@ dump_cfg (ir_graph *irg, char *suffix) current_ir_graph = rem; } +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 { + /* if small, scale to the full color range. */ + if (max < n_colors) + my = my * (n_colors/max); -void dump_callgraph(char *filesuffix) { + int step = 1 + (max / n_colors); + + color = my/step; + } + return base_color + n_colors - color; +} + +static int get_entity_color(entity *ent) { + assert(get_entity_irg(ent)); + ir_graph *irg = get_entity_irg(ent); + + 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) { @@ -2017,24 +2172,28 @@ void dump_callgraph(char *filesuffix) { 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(char *suffix) { +void dump_all_cg_block_graph(const char *suffix) { FILE *f; int i; int rem_view = interprocedural_view; @@ -2066,14 +2225,14 @@ void dump_all_cg_block_graph(char *suffix) { /***********************************************************************/ void -dump_type_graph (ir_graph *irg, char *suffix) +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; @@ -2093,7 +2252,7 @@ dump_type_graph (ir_graph *irg, char *suffix) } void -dump_all_types (char *suffix) +dump_all_types (const char *suffix) { FILE *f = vcg_open_name("All_types", suffix); dump_vcg_header(f, "All_types", NULL); @@ -2103,7 +2262,7 @@ dump_all_types (char *suffix) } void -dump_class_hierarchy (bool entities, char *suffix) +dump_class_hierarchy (bool entities, const char *suffix) { FILE *f = vcg_open_name("class_hierarchy", suffix); h_env_t env; @@ -2127,21 +2286,19 @@ dump_class_hierarchy (bool entities, char *suffix) /* dump_ir_graph_w_types */ /***********************************************************************/ -void dump_all_ir_graphs(dump_graph_func *dmp_grph, char *suffix) { - int i; - for (i=0; i < get_irp_n_irgs(); 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, son_number = 0, first = 0; loop_element le; @@ -2171,7 +2328,7 @@ void dump_loops_standalone(FILE *F, ir_loop *loop) { 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 */ + /* We are a loop node -> Collect firm nodes */ ir_node *n = le.node; int bad = 0; @@ -2193,14 +2350,11 @@ void dump_loops_standalone(FILE *F, ir_loop *loop) { fprintf (F, " "); bad |= dump_node_nodeattr(F, n); fprintf (F, " %ld", get_irn_node_nr(n)); - } -#if CALLGRAPH_LOOP_TREE - else { + if (is_Block(n)) fprintf (F, "\t ->%d", (int)get_irn_link(n)); + } else { /* for callgraph loop tree */ 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: \""); @@ -2211,10 +2365,9 @@ void dump_loops_standalone(FILE *F, ir_loop *loop) { } 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); */ } -#endif } if (loop_node_started) { @@ -2228,7 +2381,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; @@ -2236,7 +2389,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; @@ -2252,15 +2405,13 @@ 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 /*******************************************************************************/ @@ -2309,7 +2460,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();