X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firdump.c;h=1b3661199351e18012cbff6f25f26caae2ac3cad;hb=d743c7ac94ab7d3f964b075ea2bb9f6c25ec4d52;hp=c8da8a468282922d118bc0659aad136cd6275122;hpb=5052f2d2fc507aefb5d39aa7d6cc41ca55b3a2c9;p=libfirm diff --git a/ir/ir/irdump.c b/ir/ir/irdump.c index c8da8a468..1b3661199 100644 --- a/ir/ir/irdump.c +++ b/ir/ir/irdump.c @@ -1,9 +1,9 @@ /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe -** All rights reserved. -** -** Authors: Martin Trapp, Christian Schaefer -** -** irdump.h: dumping of an intermediate representation graph +* All rights reserved. +* +* Authors: Martin Trapp, Christian Schaefer +* +* irdump.h: dumping of an intermediate representation graph */ /* $Id$ */ @@ -18,7 +18,7 @@ # include "irdump.h" # include "panic.h" # include -# include "entity.h" +# include "entity_t.h" # include # include "array.h" # include "irop_t.h" @@ -26,6 +26,14 @@ # include "type_or_entity.h" # include "irgwalk.h" # include "typewalk.h" +# include "irouts.h" +# include "irdom.h" +# include "firm_common_t.h" +# include "irloop.h" + +# include "exc.h" + +# include "pmap.h" /* Attributes of nodes */ #define DEFAULT_NODE_ATTR "" @@ -35,6 +43,9 @@ #define BLOCK_EDGE_ATTR "class: 2 priority: 2 linestyle: dotted" #define CF_EDGE_ATTR "color: red" #define MEM_EDGE_ATTR "color: blue" +#define DOMINATOR_EDGE_ATTR "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" @@ -42,12 +53,13 @@ /* 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: blue" +#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" @@ -59,11 +71,14 @@ #if DEBUG_libfirm && NODEID_AS_LABEL -#define PRINT_NODEID(X) fprintf(F, "%d", get_irn_node_nr(X)) +#define PRINT_NODEID(X) fprintf(F, "%ld", get_irn_node_nr(X)) #else #define PRINT_NODEID(X) fprintf(F, "%p", X) #endif +/* A suffix to manipulate the file name. */ +char *dump_file_suffix = NULL; + /* file to dump to */ static FILE *F; @@ -71,13 +86,25 @@ static FILE *F; 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 */ +int dump_out_edge_flag = 0; +int dump_dominator_information_flag = 0; +int dump_loop_information_flag = 0; +int dump_const_local = 0; +static INLINE bool dump_const_local_set() { + if (!dump_out_edge_flag && !dump_loop_information_flag) + return dump_const_local; + else + return false; +} /* A global variable to record output of the Bad node. */ -int Bad_dumped; +static int Bad_dumped; - -void dump_ir_blocks_nodes (ir_node *n, void *env); -void dump_whole_node (ir_node *n, void* env); +static void dump_ir_blocks_nodes (ir_node *n, void *env); +static void dump_whole_node(ir_node *n, void* env); /*******************************************************************/ /* routines to dump information about a single node */ @@ -85,9 +112,10 @@ void dump_whole_node (ir_node *n, void* env); -inline void +static INLINE void dump_node_opcode (ir_node *n) { + assert(n && n->op); /* Const */ if (n->op->code == iro_Const) { @@ -96,23 +124,29 @@ dump_node_opcode (ir_node *n) /* SymConst */ } else if (n->op->code == iro_SymConst) { if (get_SymConst_kind(n) == linkage_ptr_info) { - xfprintf (F, "%I", get_SymConst_ptrinfo(n)); + /* don't use get_SymConst_ptr_info as it mangles the name. */ + xfprintf (F, "SymC %I", n->attr.i.tori.ptrinfo); } else { assert(get_kind(get_SymConst_type(n)) == k_type); assert(get_type_ident(get_SymConst_type(n))); - xfprintf (F, "%s ", id_to_str(get_type_ident(get_SymConst_type(n)))); - if (get_SymConst_kind == type_tag) - xfprintf (F, "tag"); + xfprintf (F, "SymC %I ", get_type_ident(get_SymConst_type(n))); + if (get_SymConst_kind(n) == type_tag) + xfprintf (F, "tag"); else - xfprintf (F, "size"); + xfprintf (F, "size"); } + + /* Filter */ + } else if (n->op->code == iro_Filter && !interprocedural_view) { + fprintf(F, "Proj'"); + /* all others */ } else { xfprintf (F, "%I", get_irn_opident(n)); } } -inline void +static INLINE void dump_node_mode (ir_node *n) { switch (n->op->code) { @@ -120,6 +154,7 @@ dump_node_mode (ir_node *n) case iro_Const: case iro_Id: case iro_Proj: + case iro_Filter: case iro_Conv: case iro_Tuple: case iro_Add: @@ -135,13 +170,24 @@ dump_node_mode (ir_node *n) xfprintf (F, "%I", get_mode_ident(n->mode)); break; default: + ; } } -inline void +static void dump_node_loop_info(ir_node *n) { + // if (get_irn_loop(n)) + // xfprintf(F, "\n in loop %d", get_loop_depth(get_irn_loop(n))); +} + +static INLINE void dump_node_nodeattr (ir_node *n) { switch (n->op->code) { + case iro_Start: + if (false && interprocedural_view) { + xfprintf (F, "%I", get_entity_ident(get_irg_ent(current_ir_graph))); + } + break; case iro_Proj: if (n->in[1]->op->code == iro_Cmp) { xfprintf (F, "%s", get_pnc_string(n->attr.proj)); @@ -149,19 +195,27 @@ dump_node_nodeattr (ir_node *n) xfprintf (F, "%ld", n->attr.proj); } break; + case iro_Filter: + xfprintf (F, "%ld", n->attr.filter.proj); + break; case iro_Sel: { assert(get_kind(get_Sel_entity(n)) == k_entity); - xfprintf (F, "%s", id_to_str(get_entity_ident(get_Sel_entity(n)))); + xfprintf (F, "%I", get_entity_ident(get_Sel_entity(n))); } break; default: + ; } /* end switch */ } -inline void +static INLINE void dump_node_vcgattr (ir_node *n) { switch (n->op->code) { case iro_Start: + case iro_EndReg: + /* fall through */ + case iro_EndExcept: + /* fall through */ case iro_End: xfprintf (F, "color: blue"); break; @@ -173,6 +227,7 @@ dump_node_vcgattr (ir_node *n) break; case iro_Const: case iro_Proj: + case iro_Filter: case iro_Tuple: xfprintf (F, "color: yellow"); break; @@ -181,8 +236,67 @@ dump_node_vcgattr (ir_node *n) } } -void -dump_node (ir_node *n) { +static bool pred_in_wrong_graph(ir_node *n, int pos, pmap *irgmap) { + ir_node *block = (is_Block(n)) ? n : get_nodes_Block(n); + + if (irgmap && + ((get_irn_op(n) == op_Filter) || (get_irn_op(n) == op_Block))) { + ir_node *pred = skip_Proj(get_Block_cfgpred(block, pos)); + if (is_ip_cfop(pred)) { + ir_graph *irg = get_ip_cfop_irg(pred); + if (pmap_find(irgmap, irg) == NULL) return true; + } + } + + return false; +} + + +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); +} + + +static void dump_const_node_local(ir_node *n, pmap *irgmap) { + int i; + if (!dump_const_local_set()) return; + /* Use visited flag to avoid outputting nodes twice. + initialize it first. */ + for (i = 0; i < get_irn_arity(n); i++) { + ir_node *con = get_irn_n(n, i); + if (is_constlike_node(con)) { + if (pred_in_wrong_graph(n, i, irgmap)) continue; /* pred not dumped */ + set_irn_visited(con, get_irg_visited(current_ir_graph)-1); + } + } + for (i = 0; i < get_irn_arity(n); i++) { + ir_node *con = get_irn_n(n, i); + if (is_constlike_node(con) && irn_not_visited(con)) { + if (pred_in_wrong_graph(n, i, irgmap)) continue; /* pred not dumped */ + mark_irn_visited(con); + /* Generate a new name for the node by appending the names of + n and const. */ + xfprintf (F, "node: {title: \""); PRINT_NODEID(n); PRINT_NODEID(con); + fprintf(F, "\" label: \""); + dump_node_opcode(con); + dump_node_mode (con); + xfprintf (F, " "); + dump_node_nodeattr(con); +#ifdef DEBUG_libfirm + xfprintf (F, " %ld", get_irn_node_nr(con)); +#endif + xfprintf (F, "\" "); + dump_node_vcgattr(con); + xfprintf (F, "}\n"); + } + } +} + +static void +dump_node (ir_node *n, pmap * map) { + if (dump_const_local_set() && is_constlike_node(n)) return; /* dump this node */ xfprintf (F, "node: {title: \""); PRINT_NODEID(n); fprintf(F, "\" label: \""); @@ -197,9 +311,10 @@ dump_node (ir_node *n) { xfprintf (F, "\" "); dump_node_vcgattr(n); xfprintf (F, "}\n"); + dump_const_node_local(n, map); } -void +static void dump_ir_node (ir_node *n) { /* dump this node */ @@ -210,6 +325,10 @@ dump_ir_node (ir_node *n) xfprintf (F, "\"%I\" color: blue ", get_irn_opident(n)); xfprintf (F, DEFAULT_NODE_ATTR); break; + case iro_EndReg: + /* fall through */ + case iro_EndExcept: + /* fall through */ case iro_End: xfprintf (F, "\"%I\" color: blue ", get_irn_opident(n)); xfprintf (F, DEFAULT_NODE_ATTR); @@ -242,6 +361,10 @@ dump_ir_node (ir_node *n) } xfprintf (F, DEFAULT_NODE_ATTR); break; + case iro_Filter: + xfprintf (F, "\"%I%I %ld\"", get_irn_opident(n), get_irn_modeident(n), n->attr.filter.proj); + xfprintf (F, DEFAULT_NODE_ATTR); + break; case iro_Conv: xfprintf (F, "\"%I%I\"", get_irn_opident(n), get_irn_modeident(n)); xfprintf (F, DEFAULT_NODE_ATTR); @@ -310,6 +433,10 @@ dump_ir_node (ir_node *n) xfprintf (F, "\"%I\"", get_irn_opident(n)); xfprintf (F, DEFAULT_NODE_ATTR); break; + case iro_Break: + xfprintf (F, "\"%I\"", get_irn_opident(n)); + xfprintf (F, DEFAULT_NODE_ATTR); + break; case iro_Cond: xfprintf (F, "\"%I\"", get_irn_opident(n)); xfprintf (F, DEFAULT_NODE_ATTR); @@ -318,6 +445,10 @@ dump_ir_node (ir_node *n) xfprintf (F, "\"%I\"", get_irn_opident(n)); xfprintf (F, DEFAULT_NODE_ATTR); break; + case iro_CallBegin: + xfprintf (F, "\"%I\"", get_irn_opident(n)); + xfprintf (F, DEFAULT_NODE_ATTR); + break; case iro_Return: xfprintf (F, "\"%I\"", get_irn_opident(n)); xfprintf (F, DEFAULT_NODE_ATTR); @@ -338,7 +469,7 @@ dump_ir_node (ir_node *n) case iro_Sel: assert(get_kind(get_Sel_entity(n)) == k_entity); xfprintf (F, "\"%I ", get_irn_opident(n)); - xfprintf (F, "%s", id_to_str(get_entity_ident(get_Sel_entity(n)))); + xfprintf (F, "%I", get_entity_ident(get_Sel_entity(n))); xfprintf (F, DEFAULT_NODE_ATTR); break; case iro_SymConst: @@ -366,6 +497,10 @@ dump_ir_node (ir_node *n) xfprintf (F, "\"%I%I\" ", get_irn_opident(n), get_irn_modeident(n)); xfprintf (F, DEFAULT_NODE_ATTR); break; + case iro_Unknown: + xfprintf (F, "\"%I%I\" ", get_irn_opident(n), get_irn_modeident(n)); + xfprintf (F, DEFAULT_NODE_ATTR); + break; default: xfprintf (F, "\"%I%I\" ", get_irn_opident(n), get_irn_modeident(n)); } @@ -374,8 +509,9 @@ dump_ir_node (ir_node *n) /* dump the edge to the block this node belongs to */ -void +static void dump_ir_block_edge(ir_node *n) { + if (dump_const_local_set() && is_constlike_node(n)) return; if (is_no_Block(n)) { xfprintf (F, "edge: { sourcename: \""); PRINT_NODEID(n); @@ -385,16 +521,28 @@ dump_ir_block_edge(ir_node *n) { } } -void print_edge_vcgattr(ir_node *from, int to) { +static void print_edge_vcgattr(ir_node *from, int to) { assert(from); + if (is_backedge(from, to)) xfprintf (F, BACK_EDGE_ATTR); + switch (get_irn_opcode(from)) { case iro_Block: xfprintf (F, CF_EDGE_ATTR); break; case iro_Start: break; - case iro_End: break; + case iro_End: + if (to >= 0) { + if (get_irn_mode(get_End_keepalive(from, to)) == mode_BB) + xfprintf (F, CF_EDGE_ATTR); + if (get_irn_mode(get_End_keepalive(from, to)) == mode_X) + xfprintf (F, MEM_EDGE_ATTR); + } + break; + case iro_EndReg: break; + case iro_EndExcept: break; case iro_Jmp: break; + case iro_Break: break; case iro_Cond: break; case iro_Return: case iro_Raise: @@ -406,6 +554,7 @@ void print_edge_vcgattr(ir_node *from, int to) { case iro_Call: if (to == 0) xfprintf (F, MEM_EDGE_ATTR); break; + case iro_CallBegin: break; case iro_Add: break; case iro_Sub: break; case iro_Minus: break; @@ -440,6 +589,7 @@ void print_edge_vcgattr(ir_node *from, int to) { break; case iro_Tuple: break; case iro_Proj: + case iro_Filter: switch (get_irn_modecode(from)) { case irm_X: xfprintf (F, CF_EDGE_ATTR); @@ -451,22 +601,35 @@ void print_edge_vcgattr(ir_node *from, int to) { } break; case iro_Bad: break; + case iro_Unknown: break; case iro_Id: break; default: + ; } } /* dump edges to our inputs */ -void +static void dump_ir_data_edges(ir_node *n) { - int i; + int i, visited = get_irn_visited(n); + + if ((get_irn_op(n) == op_End) && (!dump_keepalive)) + return; for (i = 0; i < get_irn_arity(n); i++) { - assert(get_irn_n(n, i)); - fprintf (F, "edge: {sourcename: \""); + ir_node * pred = get_irn_n(n, i); + assert(pred); + if ((interprocedural_view && get_irn_visited(pred) < visited)) + continue; /* pred not dumped */ + if (is_backedge(n, i)) + fprintf (F, "backedge: {sourcename: \""); + else + fprintf (F, "edge: {sourcename: \""); PRINT_NODEID(n); fprintf (F, "\" targetname: \""); - PRINT_NODEID(get_irn_n(n, i)); + if ((dump_const_local_set()) && is_constlike_node(pred)) + PRINT_NODEID(n); + PRINT_NODEID(pred); fprintf (F, "\""); fprintf (F, " label: \"%d\" ", i); print_edge_vcgattr(n, i); @@ -474,8 +637,61 @@ dump_ir_data_edges(ir_node *n) { } } +/* dump out edges */ +static void +dump_out_edge (ir_node *n, void* env) { + int i; + for (i = 0; i < get_irn_n_outs(n); i++) { + assert(get_irn_out(n, i)); + fprintf (F, "edge: {sourcename: \""); + PRINT_NODEID(n); + fprintf (F, "\" targetname: \""); + PRINT_NODEID(get_irn_out(n, i)); + fprintf (F, "\" color: red linestyle: dashed"); + fprintf (F, "}\n"); + } +} + +static INLINE void +dump_loop_node_edge (ir_loop *loop, int i) { + assert(loop); + fprintf (F, "edge: {sourcename: \"%p\" targetname: \"", loop); + PRINT_NODEID(get_loop_node(loop, i)); + fprintf (F, "\" color: green"); + fprintf (F, "}\n"); +} + +static +void dump_loops (ir_loop *loop) { + int i; + /* dump this loop node */ + xfprintf (F, "node: {title: \"%p\" label: \"loop %d, %d sons, %d nodes\" }\n", + loop, get_loop_depth(loop), get_loop_n_sons(loop), get_loop_n_nodes(loop)); + /* dump edges to nodes in loop -- only if it is a real loop */ + if (get_loop_depth(loop) != 0) { + for (i = 0; i < get_loop_n_nodes(loop); i++) { + dump_loop_node_edge(loop, i); + } + } + for (i = 0; i < get_loop_n_sons(loop); i++) { + dump_loops(get_loop_son(loop, i)); + } +} + +static INLINE +void dump_loop_info(ir_graph *irg) { + ir_graph *rem = current_ir_graph; + current_ir_graph = irg; + + if (get_irg_loop(irg)) + dump_loops(get_irg_loop(irg)); + + current_ir_graph = rem; +} + + /* dumps the edges between nodes and their type or entity attributes. */ -void dump_node2type_edges (ir_node *n, void *env) +static void dump_node2type_edges (ir_node *n, void *env) { assert(n); @@ -522,24 +738,116 @@ void dump_node2type_edges (ir_node *n, void *env) } -void dump_const_expression(ir_node *value) { +static void dump_const_expression(ir_node *value) { ir_graph *rem = current_ir_graph; + int rem_dump_const_local = dump_const_local; + dump_const_local = 0; current_ir_graph = get_const_code_irg(); irg_walk(value, dump_ir_blocks_nodes, NULL, get_nodes_Block(value)); set_irg_visited(current_ir_graph, get_irg_visited(current_ir_graph) -1); current_ir_graph = rem; + dump_const_local = rem_dump_const_local; +} + + +static void print_type_info(type *tp) { + if (get_type_state(tp) == layout_undefined) { + xfprintf(F, "state: layout_undefined\n"); + } else { + xfprintf(F, "state: layout_fixed,\n"); + } + if (get_type_mode(tp)) + xfprintf(F, "mode: %s,\n", get_mode_name(get_type_mode(tp))); + xfprintf(F, "size: %dB,\n", get_type_size(tp)); +} + + +static void print_typespecific_info(type *tp) { + switch (get_type_tpop_code(tp)) { + case tpo_class: + { + if(existent == get_class_peculiarity(tp)) + xfprintf (F, " " TYPE_CLASS_NODE_ATTR); + else + xfprintf (F, " " TYPE_DESCRIPTION_NODE_ATTR); + } break; + case tpo_struct: + { + xfprintf (F, " " TYPE_METH_NODE_ATTR); + } break; + case tpo_method: + { + } break; + case tpo_union: + { + } break; + case tpo_array: + { + } break; + case tpo_enumeration: + { + } break; + case tpo_pointer: + { + } break; + case tpo_primitive: + { + } break; + default: break; + } /* switch type */ } +static void print_type_node(type *tp) { + xfprintf (F, "node: {title: \"%p\" ", tp); + xfprintf (F, "label: \"%I %I\"", get_type_tpop_nameid(tp), get_type_ident(tp)); + xfprintf (F, "info1: \""); + print_type_info(tp); + xfprintf (F, "\""); + print_typespecific_info(tp); + xfprintf (F, "}\n"); +} + +void dump_entity_node(entity *ent) { + xfprintf (F, "node: {title: \"%p\" ", ent); + xfprintf (F, DEFAULT_TYPE_ATTRIBUTE); + xfprintf (F, "label: "); + xfprintf (F, "\"ent %I\" " ENTITY_NODE_ATTR , get_entity_ident(ent)); + switch (get_entity_allocation(ent)) { + case dynamic_allocated: fprintf (F, " info1:\"dynamic allocated\n"); break; + case automatic_allocated: fprintf (F, " info1:\"automatic allocated\n"); break; + case static_allocated: fprintf (F, " info1:\"static allocated\n"); break; + } + switch (get_entity_visibility(ent)) { + case local: fprintf (F, "local\n"); break; + case external_visible: fprintf (F, "external_visible\n"); break; + case external_allocated: fprintf (F, "external_allocate\n"); break; + } + switch (get_entity_variability(ent)) { + case uninitialized: fprintf (F, "uninitialized\n");break; + case initialized: fprintf (F, "initialized\n"); break; + case part_constant: fprintf (F, "part_constant\n");break; + case constant: fprintf (F, "constant\n"); break; + } + switch (get_entity_volatility(ent)) { + case non_volatile: fprintf (F, "non_volatile\n"); break; + case is_volatile: fprintf (F, "is_volatile\n"); break; + } + switch (get_entity_peculiarity(ent)) { + case description: fprintf (F, "description\n"); break; + case inherited: fprintf (F, "inherited\n"); break; + case existent: fprintf (F, "existent\n"); break; + } + if (is_method_type(get_entity_type(ent))) + xfprintf (F, "\n irg = %p ", get_entity_irg(ent)); + xfprintf(F, "\"}\n"); +} /* dumps a type or entity and it's edges. */ -void +static void dump_type_info (type_or_ent *tore, void *env) { int i = 0; /* to shutup gcc */ /* dump this type or entity */ - xfprintf (F, "node: {title: \"%p\" ", tore); - xfprintf (F, DEFAULT_TYPE_ATTRIBUTE); - xfprintf (F, "label: "); switch (get_kind(tore)) { case k_entity: @@ -547,31 +855,19 @@ dump_type_info (type_or_ent *tore, void *env) { entity *ent = (entity *)tore; ir_node *value; /* The node */ - xfprintf (F, "\"ent %I\" " ENTITY_NODE_ATTR , get_entity_ident(ent)); - if(dynamic_allocated == get_entity_allocation(ent)) - xfprintf (F, " info1:\"dynamic allocated\n"); - else - xfprintf (F, " info1:\"static allocated\n"); - switch (get_entity_visibility(ent)) { - case local: fprintf (F, "local\n"); break; - case external_visible: fprintf (F, "external_visible\n"); break; - case external_allocated: fprintf (F, "external_allocate\nd");break; - } - switch (get_entity_variability(ent)) { - case uninitialized: fprintf (F, "uninitialized");break; - case initialized: fprintf (F, "initialized"); break; - case part_constant: fprintf (F, "part_constant");break; - case constant: fprintf (F, "constant"); break; - } - xfprintf(F, "\"}\n"); + dump_entity_node(ent); /* The Edges */ + /* skip this to reduce graph. Member edge of type is parallel to this edge. * xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" " - ENT_OWN_EDGE_ATTR "}\n", ent, get_entity_owner(ent)); + ENT_OWN_EDGE_ATTR "}\n", ent, get_entity_owner(ent));*/ xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" " ENT_TYPE_EDGE_ATTR "}\n", ent, get_entity_type(ent)); - for(i = 0; i < get_entity_n_overwrites(ent); i++) - xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" " - ENT_OVERWRITES_EDGE_ATTR "}\n", ent, get_entity_overwrites(ent, i)); + if(is_class_type(get_entity_owner(ent))) { + for(i = 0; i < get_entity_n_overwrites(ent); i++) + xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" " + ENT_OVERWRITES_EDGE_ATTR "}\n", + ent, get_entity_overwrites(ent, i)); + } /* attached subgraphs */ if (const_entities && (get_entity_variability(ent) != uninitialized)) { if (is_atomic_entity(ent)) { @@ -598,44 +894,40 @@ dump_type_info (type_or_ent *tore, void *env) { case k_type: { type *tp = (type *)tore; - xfprintf (F, "\"%I %I", get_type_tpop_nameid(tp), get_type_ident(tp)); - + print_type_node(tp); + /* and now the edges */ switch (get_type_tpop_code(tp)) { case tpo_class: { - xfprintf (F, "\" " TYPE_CLASS_NODE_ATTR "}\n"); - for (i=0; i < get_class_n_supertype(tp); i++) + for (i=0; i < get_class_n_supertypes(tp); i++) xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" " TYPE_SUPER_EDGE_ATTR "}\n", tp, get_class_supertype(tp, i)); - for (i=0; i < get_class_n_member(tp); i++) + for (i=0; i < get_class_n_members(tp); i++) xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" " TYPE_MEMBER_EDGE_ATTR "}\n", tp, get_class_member(tp, i)); } break; case tpo_struct: { - xfprintf (F, "\"}\n"); - for (i=0; i < get_struct_n_member(tp); i++) + for (i=0; i < get_struct_n_members(tp); i++) xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" " TYPE_MEMBER_EDGE_ATTR "}\n", tp, get_struct_member(tp, i)); } break; case tpo_method: { - xfprintf (F, "\" " TYPE_METH_NODE_ATTR "}\n"); for (i = 0; i < get_method_n_params(tp); i++) xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" " METH_PAR_EDGE_ATTR "}\n", tp, get_method_param_type(tp, i), i); - for (i = 0; i < get_method_n_res(tp); i++) + for (i = 0; i < get_method_n_ress(tp); i++) xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" " METH_RES_EDGE_ATTR "}\n", tp, get_method_res_type(tp, i), i); } break; case tpo_union: { - xfprintf (F, "\"}\n"); for (i = 0; i < get_union_n_members(tp); i++) xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" " "label: \"\"f" UNION_EDGE_ATTR "}\n", @@ -643,7 +935,6 @@ dump_type_info (type_or_ent *tore, void *env) { } break; case tpo_array: { - xfprintf (F, "\"}\n"); xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" " ARR_ELT_TYPE_EDGE_ATTR "}\n", tp, get_array_element_type(tp), i); xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" " @@ -651,18 +942,15 @@ dump_type_info (type_or_ent *tore, void *env) { } break; case tpo_enumeration: { - xfprintf (F, "\"}\n"); } break; case tpo_pointer: { - xfprintf (F, "\"}\n"); xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" " PTR_PTS_TO_EDGE_ATTR "}\n", tp, get_pointer_points_to_type(tp), i); } break; case tpo_primitive: { - xfprintf (F, " (mode %I)\"}\n", get_mode_ident(get_type_mode(tp))); } break; default: break; } /* switch type */ @@ -670,8 +958,52 @@ dump_type_info (type_or_ent *tore, void *env) { break; /* case k_type */ default: { - xfprintf (F, "\" faulty type \"}\n"); - printf(" *** irdump, %s(l.%i), faulty type.\n", __FUNCTION__, __LINE__); + printf(" *** irdump, dump_type_info(l.%i), faulty type.\n", __LINE__); + } break; + } /* switch kind_or_entity */ +} + +/* dumps a class type node and a superclass edge. + If env != null dumps entities of classes and overwrites edges. */ +static void +dump_class_hierarchy_node (type_or_ent *tore, void *env) { + int i = 0; /* to shutup gcc */ + + /* dump this type or entity */ + switch (get_kind(tore)) { + case k_entity: { + entity *ent = (entity *)tore; + if ((env) && is_class_type(get_entity_owner(ent))) { + /* The node */ + dump_entity_node(ent); + /* The edges */ + xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" " + TYPE_MEMBER_EDGE_ATTR "}\n", get_entity_owner(ent), ent); + for(i = 0; i < get_entity_n_overwrites(ent); i++) + xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" " + ENT_OVERWRITES_EDGE_ATTR "}\n", + ent, get_entity_overwrites(ent, i)); + } + } break; /* case k_entity */ + case k_type: + { + type *tp = (type *)tore; + switch (get_type_tpop_code(tp)) { + case tpo_class: { + print_type_node(tp); + /* and now the edges */ + for (i=0; i < get_class_n_supertypes(tp); i++) + xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" " + TYPE_SUPER_EDGE_ATTR "}\n", + tp, get_class_supertype(tp, i)); + } break; + default: break; + } /* switch type */ + } + break; /* case k_type */ + default: + { + printf(" *** irdump, dump_class_hierarchy_node(l.%i), faulty type.\n", __LINE__); } break; } /* switch kind_or_entity */ } @@ -680,30 +1012,28 @@ dump_type_info (type_or_ent *tore, void *env) { /* open and close vcg file */ /************************************************************************/ -void vcg_open (ir_graph *irg, char *suffix) { +static void vcg_open (ir_graph *irg, char *suffix) { char *fname; /* filename to put the vcg information in */ const char *cp; ident *id; int len; char label[4]; + entity *ent; /** open file for vcg graph */ - id = get_entity_ld_ident (get_irg_ent(irg)); + ent = get_irg_ent(irg); + id = ent->ld_name ? ent->ld_name : ent->name; + /* Don't use get_entity_ld_ident (ent) as it computes the mangled name! */ len = id_to_strlen (id); cp = id_to_str (id); - - fname = malloc (len + 5 + strlen(suffix)); + if (dump_file_suffix) + fname = malloc (len + 5 + strlen(suffix) + strlen(dump_file_suffix)); + else + fname = malloc (len + 5 + strlen(suffix)); strncpy (fname, cp, len); /* copy the filename */ fname[len] = '\0'; + if (dump_file_suffix) strcat (fname, dump_file_suffix); /* append file suffix */ strcat (fname, suffix); /* append file suffix */ - - fname = malloc (len + 5 + strlen(suffix)); - strncpy (fname, cp, len); /* copy the filename */ - fname[len] = '\0'; /* ensure string termination */ - /*strcpy (fname, cp); * copy the filename * - this produces wrong, too long strings in conjuction with the - jocca frontend. The \0 seems to be missing. */ - strcat (fname, suffix); /* append file suffix */ strcat (fname, ".vcg"); /* append the .vcg suffix */ F = fopen (fname, "w"); /* open file for writing */ if (!F) { @@ -741,7 +1071,7 @@ void vcg_open (ir_graph *irg, char *suffix) { xfprintf (F, "\n"); /* a separator */ } -void vcg_open_name (const char *name) { +static void vcg_open_name (const char *name) { char *fname; /* filename to put the vcg information in */ int len; char label[4]; @@ -749,7 +1079,12 @@ void vcg_open_name (const char *name) { /** open file for vcg graph */ len = strlen(name); fname = malloc (len + 5); + if (dump_file_suffix) + fname = malloc (len + 5 + strlen(dump_file_suffix)); + else + fname = malloc (len + 5); strcpy (fname, name); /* copy the filename */ + if (dump_file_suffix) strcat (fname, dump_file_suffix); strcat (fname, ".vcg"); /* append the .vcg suffix */ F = fopen (fname, "w"); /* open file for writing */ if (!F) { @@ -787,7 +1122,7 @@ void vcg_open_name (const char *name) { xfprintf (F, "\n"); /* a separator */ } -void +static void vcg_close () { xfprintf (F, "}\n"); /* print footer */ fclose (F); /* close vcg file */ @@ -797,10 +1132,15 @@ vcg_close () { /* routines to dump a graph, blocks as conventional nodes. */ /************************************************************************/ -void +static int node_floats(ir_node *n) { + return ((get_op_pinned(get_irn_op(n)) == floats) && + (get_irg_pinned(current_ir_graph) == floats)); +} + +static void dump_whole_node (ir_node *n, void* env) { - dump_node(n); - dump_ir_block_edge(n); + dump_node(n, NULL); + if (!node_floats(n)) dump_ir_block_edge(n); dump_ir_data_edges(n); } @@ -814,7 +1154,13 @@ dump_ir_graph (ir_graph *irg) vcg_open (irg, ""); /* walk over the graph */ - irg_walk(irg->end, dump_whole_node, NULL, NULL); + /* dump_whole_node must be called in post visiting predecessors */ + irg_walk(irg->end, NULL, dump_whole_node, NULL); + + /* dump the out edges in a separate walk */ + if ((dump_out_edge_flag) && (get_irg_outs_state(irg) != no_outs)) { + irg_out_walk(irg->start, dump_out_edge, NULL, NULL); + } vcg_close(); @@ -825,32 +1171,38 @@ dump_ir_graph (ir_graph *irg) /* the following routines dump the nodes as attached to the blocks. */ /***********************************************************************/ -void +static void dump_ir_blocks_nodes (ir_node *n, void *env) { ir_node *block = (ir_node *)env; - if (is_no_Block(n) && get_nodes_Block(n) == block) { - dump_node(n); + if (is_no_Block(n) && get_nodes_Block(n) == block && !node_floats(n)) { + dump_node(n, NULL); dump_ir_data_edges(n); } if (get_irn_op(n) == op_Bad) Bad_dumped = 1; } -void +static void dump_ir_block (ir_node *block, void *env) { ir_graph *irg = (ir_graph *)env; if (get_irn_opcode(block) == iro_Block) { /* This is a block. So dump the vcg information to make a block. */ - xfprintf(F, "graph: { title: \""); PRINT_NODEID(block); fprintf(F, "\" label: \""); + xfprintf(F, "graph: { title: \""); + PRINT_NODEID(block); + fprintf(F, "\" label: \""); #ifdef DEBUG_libfirm xfprintf (F, "%ld", get_irn_node_nr(block)); #else xfprintf (F, "%I", block->op->name); #endif - xfprintf(F, "\" status:clustered color:lightyellow \n"); + if (exc_normal != get_Block_exc (block)) + fprintf (F, " (%s)", exc_to_string (get_Block_exc (block))); + + xfprintf(F, "\" status:clustered color:%s \n", + get_Block_matured (block) ? "yellow" : "red"); /* dump the blocks edges */ dump_ir_data_edges(block); @@ -859,22 +1211,28 @@ dump_ir_block (ir_node *block, void *env) { /* Close the vcg information for the block */ xfprintf(F, "}\n\n"); + dump_const_node_local(block, NULL); } } -void +static void dump_blockless_nodes (ir_node *n, void *env) { if (is_no_Block(n) && get_irn_op(get_nodes_Block(n)) == op_Bad) { - dump_node(n); + dump_node(n, NULL); dump_ir_data_edges(n); dump_ir_block_edge(n); + if (get_irn_op(n) == op_Bad) Bad_dumped = 1; + return; + } + if (node_floats(n)) { + dump_node(n, NULL); + dump_ir_data_edges(n); + if (get_irn_op(n) == op_Bad) Bad_dumped = 1; } - if (get_irn_op(n) == op_Bad) - Bad_dumped = 1; } -void dump_ir_block_graph_2 (ir_graph *irg) +static void dump_ir_block_graph_2 (ir_graph *irg) { Bad_dumped = 0; /* walk over the blocks in the graph */ @@ -885,7 +1243,7 @@ void dump_ir_block_graph_2 (ir_graph *irg) /* dump the Bad node */ if (!Bad_dumped) - dump_node(get_irg_bad(irg)); + dump_node(get_irg_bad(irg), NULL); } void @@ -899,6 +1257,8 @@ dump_ir_block_graph (ir_graph *irg) dump_ir_block_graph_2 (irg); + if (dump_loop_information_flag) dump_loop_info(irg); + vcg_close(); current_ir_graph = rem; } @@ -909,23 +1269,42 @@ dump_ir_block_graph (ir_graph *irg) /***********************************************************************/ -void +static void dump_block_to_cfg (ir_node *block, void *env) { int i; ir_node *pred; if (get_irn_opcode(block) == iro_Block) { /* This is a block. Dump a node for the block. */ - xfprintf (F, "node: {title: \"%p\" label: \"%I\"}", block, - block->op->name); + xfprintf (F, "node: {title:\""); PRINT_NODEID(block); + xfprintf (F, "\" label: \"%I ", block->op->name); PRINT_NODEID(block); + + if (exc_normal != get_Block_exc (block)) + xfprintf (F, " (%s)", exc_to_string (get_Block_exc (block))); + + xfprintf (F, "\" "); + if (dump_dominator_information_flag) + xfprintf(F, "info1:\"dom depth %d\"", get_Block_dom_depth(block)); + xfprintf (F, "}\n"); /* Dump the edges */ - for ( i = 0; i < get_Block_n_cfgpreds(block); i++) { - pred = get_nodes_Block(skip_Proj(get_Block_cfgpred(block, i))); + 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))); + xfprintf (F, "edge: { sourcename: \""); + PRINT_NODEID(block); + fprintf (F, "\" targetname: \""); + PRINT_NODEID(pred); + fprintf (F, "\" }\n"); + } + + /* Dump dominator edge */ + if (dump_dominator_information_flag && get_Block_idom(block)) { + pred = get_Block_idom(block); xfprintf (F, "edge: { sourcename: \""); PRINT_NODEID(block); fprintf (F, "\" targetname: \""); PRINT_NODEID(pred); - fprintf (F, "\" }\n"); + fprintf (F, "\" " DOMINATOR_EDGE_ATTR "}\n"); } } } @@ -933,12 +1312,21 @@ dump_block_to_cfg (ir_node *block, void *env) { void dump_cfg (ir_graph *irg) { + ir_graph *rem = current_ir_graph; + int ddif = dump_dominator_information_flag; + current_ir_graph = irg; vcg_open (irg, "-cfg"); + if (get_irg_dom_state(irg) != dom_consistent) + dump_dominator_information_flag = 0; + /* walk over the blocks in the graph */ irg_block_walk(irg->end, dump_block_to_cfg, NULL, NULL); + dump_ir_node (irg->bad); + dump_dominator_information_flag = ddif; vcg_close(); + current_ir_graph = rem; } @@ -983,6 +1371,17 @@ dump_all_types (void) vcg_close(); } +void +dump_class_hierarchy (bool entities) +{ + vcg_open_name ("class_hierarchy"); + if (entities) + type_walk(dump_class_hierarchy_node, NULL, (void *)1); + else + type_walk(dump_class_hierarchy_node, NULL, NULL); + vcg_close(); +} + /***********************************************************************/ /* dumps a graph with type information */ /***********************************************************************/ @@ -1038,7 +1437,7 @@ dump_ir_block_graph_w_types (ir_graph *irg) /* dump_type_graph */ /* dump_ir_graph_w_types */ /***********************************************************************/ -void dump_all_ir_graphs (void dump_graph(ir_graph*)) { +void dump_all_ir_graphs (dump_graph_func *dump_graph) { int i; for (i=0; i < get_irp_n_irgs(); i++) { dump_graph(get_irp_irg(i)); @@ -1048,10 +1447,231 @@ void dump_all_ir_graphs (void dump_graph(ir_graph*)) { /* To turn off display of edge labels. Edge labels offen cause xvcg to abort with a segmentation fault. */ -void turn_of_edge_labels() { +void turn_off_edge_labels() { edge_label = 0; } -void dump_constant_entity_values() { + +void dump_consts_local(bool b) { + dump_const_local = b; +} + +void turn_off_constant_entity_values() { const_entities = 0; } + +void dump_keepalive_edges(bool b) { + dump_keepalive = b; +} + +void dump_out_edges() { + dump_out_edge_flag = 1; +} + +void dump_dominator_information() { + dump_dominator_information_flag = 1; +} + +void dump_loop_information() { + dump_loop_information_flag = 1; +} + +void dont_dump_loop_information() { + dump_loop_information_flag = 0; +} + +static void clear_link(ir_node * node, void * env) { + set_irn_link(node, NULL); +} + +static void collect_blocks_floats_cg(ir_node * node, pmap * map) { + if (is_Block(node) + || node_floats(node) + || get_irn_op(node) == op_Bad + || get_irn_op(node) == op_Unknown) { + pmap_entry * entry = pmap_find(map, current_ir_graph); + if (entry) { + ARR_APP1(ir_node *, (ir_node **) entry->value, node); + } else { + ir_node ** arr = NEW_ARR_F(ir_node *, 1); + arr[0] = node; + pmap_insert(map, current_ir_graph, arr); + } + } else { + ir_node * block = get_nodes_Block(node); + set_irn_link(node, get_irn_link(block)); + set_irn_link(block, node); + } +} + + +static void dump_cg_ir_block(ir_node * block, void * env) { + ir_node *node; + pmap *irgmap = (pmap *)env; + assert(is_Block(block)); + xfprintf(F, "graph: { title: \""); + PRINT_NODEID(block); + fprintf(F, "\" label: \""); +#ifdef DEBUG_libfirm + xfprintf (F, "%ld", get_irn_node_nr(block)); +#else + xfprintf (F, "%I", block->op->name); +#endif + if (exc_normal != get_Block_exc(block)) { + fprintf (F, " (%s)", exc_to_string (get_Block_exc(block))); + } + + xfprintf(F, "\" status:clustered color:%s \n", + get_Block_matured(block) ? "yellow" : "red"); + + /* dump the blocks edges */ + dump_ir_data_edges(block); + + /* dump the nodes that go into the block */ + for (node = get_irn_link(block); node; node = get_irn_link(node)) { + dump_node(node, irgmap); + dump_ir_data_edges(node); + } + + /* Close the vcg information for the block */ + xfprintf(F, "}\n\n"); +} + +static void d_cg_block_graph(ir_graph *irg, ir_node **arr, pmap *irgmap) { + int i; + + xfprintf(F, "graph: { title: \"%p\" label: \"%I\" status:clustered color:white \n", + irg, get_entity_ident(get_irg_ent(irg))); + + for (i = ARR_LEN(arr) - 1; i >= 0; --i) { + ir_node * node = arr[i]; + if (is_Block(node)) { + /* Dumps the block and all the nodes in the block , which are to + be found in Block->link. */ + dump_cg_ir_block(node, irgmap); + } else { + /* Nodes that are not in a Block. */ + dump_node(node, NULL); + dump_ir_data_edges(node); + } + } + /* Close the vcg information for the irg */ + xfprintf(F, "}\n\n"); +} + +/* dump interprocedural graph with surrounding methods */ +void dump_cg_block_graph(ir_graph * irg) { + pmap * map = pmap_create(); + pmap * map2 = pmap_create(); + pmap_entry * entry; + + vcg_open(irg, ""); + + irg_walk_graph(irg, clear_link, (irg_walk_func *) collect_blocks_floats_cg, map); + for (entry = pmap_first(map); entry; entry = pmap_next(map)) + pmap_insert(map2, entry->key, entry->value); + for (entry = pmap_first(map); entry; entry = pmap_next(map)) { + d_cg_block_graph(entry->key, entry->value, map2); + DEL_ARR_F(entry->value); + } + + pmap_destroy(map); + pmap_destroy(map2); + + if (dump_loop_information_flag) dump_loop_info(irg); + vcg_close(); +} + +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) { + ir_node ** arr = (ir_node **) get_irg_link(current_ir_graph); + ARR_APP1(ir_node *, arr, node); + set_irg_link(current_ir_graph, arr); /* arr is an l-value, APP_ARR might change it! */ + } else { + ir_node * block = get_nodes_Block(node); + set_irn_link(node, get_irn_link(block)); + set_irn_link(block, node); + } +} + +/* Links all nodes that have the block field set in the link field of + the block. Adds all blocks and nodes not associated with a block + in a array in irg->link. */ +static void collect_nodes() { + int i; + for (i = 0; i < get_irp_n_irgs(); i++) + set_irg_link(get_irp_irg(i), NEW_ARR_F(ir_node *, 0)); + cg_walk(clear_link, collect_node, NULL); +} + +static void dump_graphs() { + int i; + for (i = 0; i < get_irp_n_irgs(); i++) { + current_ir_graph = get_irp_irg(i); + d_cg_block_graph(current_ir_graph, get_irg_link(current_ir_graph), NULL); + } +} + +/* Dump all irgs in interprocedural view to a single file. */ +void dump_all_cg_block_graph() { + int i; + int rem_view = interprocedural_view; + interprocedural_view = 1; + vcg_open_name ("All_graphs"); + + collect_nodes(); + dump_graphs(); + + if (dump_loop_information_flag) + for (i = 0; i < get_irp_n_irgs(); i++) + dump_loop_info(get_irp_irg(i)); + + vcg_close(); + interprocedural_view = rem_view; +} + +/* dump interprocedural block graph with surrounding methods */ +void dump_cg_graph(ir_graph * irg) { + pmap * map = pmap_create(); + pmap * map2 = pmap_create(); /* We can not iterate in the same map twice! */ + pmap_entry * entry; + vcg_open(irg, ""); + + irg_walk_graph(irg, clear_link, (irg_walk_func *) collect_blocks_floats_cg, map); + for (entry = pmap_first(map); entry; entry = pmap_next(map)) + pmap_insert(map2, entry->key, entry->value); + for (entry = pmap_first(map); entry; entry = pmap_next(map)) { + ir_node ** arr = entry->value; + int i; + ident * irg_ident = get_entity_ident(get_irg_ent(entry->key)); + + xfprintf(F, "graph: { title: \"%I\" label: \"%I\" status:clustered color:white \n", + irg_ident, irg_ident); + + for (i = ARR_LEN(arr) - 1; i >= 0; --i) { + ir_node * node = arr[i]; + dump_node(node, map2); + dump_ir_data_edges(node); + if (is_Block(node)) { + for (node = get_irn_link(node); node; node = get_irn_link(node)) { + dump_node(node, map2); + dump_ir_block_edge(node); + dump_ir_data_edges(node); + } + } + } + + DEL_ARR_F(arr); + + /* Close the vcg information for the irg */ + xfprintf(F, "}\n\n"); + } + + pmap_destroy(map); + pmap_destroy(map2); + + vcg_close(); +}