X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firdumptxt.c;h=c5a99de20ab372e0b27a83602ceed9424ee031a0;hb=637542932dc27dcdfc7def09b58d9d5d4c34fb77;hp=0c4ef9526e8b0277f137c1f7e9cdfddb9d8a5654;hpb=547c5ad02911176577704dedd5c901ffc0218bb2;p=libfirm diff --git a/ir/ir/irdumptxt.c b/ir/ir/irdumptxt.c index 0c4ef9526..c5a99de20 100644 --- a/ir/ir/irdumptxt.c +++ b/ir/ir/irdumptxt.c @@ -31,14 +31,13 @@ #include "entity_t.h" #include "trouts.h" #include "irgwalk.h" +#include "tv_t.h" +#include "irdom.h" #include "field_temperature.h" #define MY_SIZE 1024 /* Size of an array that actually should be computed. */ -int dump_node_opcode(FILE *F, ir_node *n); /* from irdump.c */ - - /* Just opens a file, mangling a file name. * * The name consists of the following parts: @@ -163,7 +162,25 @@ int dump_irnode_to_file(FILE *F, ir_node *n) { switch (get_irn_opcode(n)) { case iro_Block: { fprintf(F, " block visited: %ld\n", get_Block_block_visited(n)); - fprintf(F, " dominator info: output not implemented\n"); + if (get_irg_dom_state(get_irn_irg(n)) != dom_none) { + fprintf(F, " dom depth %d\n", get_Block_dom_depth(n)); + fprintf(F, " tree pre num %d\n", get_Block_dom_tree_pre_num(n)); + fprintf(F, " max subtree pre num %d\n", get_Block_dom_max_subtree_pre_num(n)); + } + + fprintf(F, " Execution freqency statistics:\n"); + if (get_irg_exec_freq_state(get_irn_irg(n)) != exec_freq_none) + fprintf(F, " procedure local evaluation: %8.2lf\n", get_irn_exec_freq(n)); + if (get_irp_loop_nesting_depth_state() != loop_nesting_depth_none) + fprintf(F, " call freqency of procedure: %8.2lf\n", + get_irg_method_execution_frequency(get_irn_irg(n))); + if (get_irp_callgraph_state() == irp_callgraph_and_calltree_consistent) + fprintf(F, " recursion depth of procedure: %8.2lf\n", (double)get_irn_recursion_depth(n)); + if ((get_irg_exec_freq_state(get_irn_irg(n)) != exec_freq_none) && + (get_irp_loop_nesting_depth_state() != loop_nesting_depth_none) && + (get_irp_callgraph_state() == irp_callgraph_and_calltree_consistent)) + fprintf(F, " final evaluation: **%8.2lf**\n", get_irn_final_cost(n)); + /* not dumped: graph_arr */ /* not dumped: mature */ } break; @@ -379,6 +396,62 @@ int addr_is_alloc(ir_node *acc) { return 1; } +/** dumps something like: + * + * "prefix" "Name" (x): node1, ... node7,\n + * "prefix" node8, ... node15,\n + * "prefix" node16, node17\n + */ +static void dump_node_list(FILE *F, firm_kind *k, char *prefix, + int (*get_entity_n_nodes)(firm_kind *ent), + ir_node *(*get_entity_node)(firm_kind *ent, int pos), + char *name) { + int i, n_nodes = get_entity_n_nodes(k); + char *comma = ""; + + fprintf(F, "%s %s (%d):", prefix, name, n_nodes); + for (i = 0; i < n_nodes; ++i) { + int rem; + if (i > 7 && !(i & 7)) { /* line break every eigth node. */ + fprintf(F, ",\n%s ", prefix); + comma = ""; + } + fprintf(F, "%s ", comma); + rem = opt_dump_analysed_type_info; + opt_dump_analysed_type_info = 0; + dump_node_label(F, get_entity_node(k, i)); + opt_dump_analysed_type_info = rem; + comma = ","; + } + fprintf(F, "\n"); +} + +/** dumps something like: + * + * "prefix" "Name" (x): node1, ... node7,\n + * "prefix" node8, ... node15,\n + * "prefix" node16, node17\n + */ +static void dump_type_list(FILE *F, type *tp, char *prefix, + int (*get_n_types)(type *tp), + type *(*get_type)(type *tp, int pos), + char *name) { + int i, n_nodes = get_n_types(tp); + char *comma = ""; + + fprintf(F, "%s %s (%d):", prefix, name, n_nodes); + for (i = 0; i < n_nodes; ++i) { + if (i > 7 && !(i & 7)) { /* line break every eigth node. */ + fprintf(F, ",\n%s ", prefix); + comma = ""; + } + fprintf(F, "%s %s(%ld)", comma, get_type_name(get_type(tp, i)), get_type_nr(tp)); + //dump_type_to_file(F, get_type(tp, i), dump_verbosity_onlynames); + comma = ","; + } + fprintf(F, "\n"); +} + #define X(a) case a: fprintf(F, #a); break void dump_entity_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned verbosity) { int i, j; @@ -400,24 +473,42 @@ void dump_entity_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned if (is_Class_type(get_entity_owner(ent))) { if (get_entity_n_overwrites(ent) > 0) { - fprintf(F, "%s overwrites:\n", prefix); - for (i = 0; i < get_entity_n_overwrites(ent); ++i) { - entity *ov = get_entity_overwrites(ent, i); - fprintf(F, "%s %d: %s of class %s\n", prefix, i, get_entity_name(ov), - get_type_name(get_entity_owner(ov))); - } + fprintf(F, "%s overwrites:\n", prefix); + for (i = 0; i < get_entity_n_overwrites(ent); ++i) { + entity *ov = get_entity_overwrites(ent, i); + fprintf(F, "%s %d: %s of class %s\n", prefix, i, get_entity_name(ov), + get_type_name(get_entity_owner(ov))); + } } else { - fprintf(F, "%s Does not overwrite other entities. \n", prefix); + fprintf(F, "%s Does not overwrite other entities. \n", prefix); } if (get_entity_n_overwrittenby(ent) > 0) { - fprintf(F, "%s overwritten by:\n", prefix); - for (i = 0; i < get_entity_n_overwrittenby(ent); ++i) { - entity *ov = get_entity_overwrittenby(ent, i); - fprintf(F, "%s %d: %s of class %s\n", prefix, i, get_entity_name(ov), - get_type_name(get_entity_owner(ov))); + fprintf(F, "%s overwritten by:\n", prefix); + for (i = 0; i < get_entity_n_overwrittenby(ent); ++i) { + entity *ov = get_entity_overwrittenby(ent, i); + fprintf(F, "%s %d: %s of class %s\n", prefix, i, get_entity_name(ov), + get_type_name(get_entity_owner(ov))); } } else { - fprintf(F, "%s Is not overwritten by other entities. \n", prefix); + fprintf(F, "%s Is not overwritten by other entities. \n", prefix); + } + + if (get_irp_inh_transitive_closure_state() != inh_transitive_closure_none) { + entity *ov; + fprintf(F, "%s transitive overwrites:\n", prefix); + for (ov = get_entity_trans_overwrites_first(ent); + ov; + ov = get_entity_trans_overwrites_next(ent)) { + fprintf(F, "%s : %s of class %s\n", prefix, get_entity_name(ov), + get_type_name(get_entity_owner(ov))); + } + fprintf(F, "%s transitive overwritten by:\n", prefix); + for (ov = get_entity_trans_overwrittenby_first(ent); + ov; + ov = get_entity_trans_overwrittenby_next(ent)) { + fprintf(F, "%s : %s of class %s\n", prefix, get_entity_name(ov), + get_type_name(get_entity_owner(ov))); + } } } @@ -460,26 +551,26 @@ void dump_entity_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned if (verbosity & dump_verbosity_entconsts) { if (get_entity_variability(ent) != variability_uninitialized) { if (is_atomic_entity(ent)) { - fprintf(F, "%s atomic value: ", prefix); - dump_node_opcode(F, get_atomic_ent_value(ent)); + fprintf(F, "%s atomic value: ", prefix); + dump_node_opcode(F, get_atomic_ent_value(ent)); } else { - fprintf(F, "%s compound values:", prefix); - for (i = 0; i < get_compound_ent_n_values(ent); ++i) { - compound_graph_path *path = get_compound_ent_value_path(ent, i); - entity *ent0 = get_compound_graph_path_node(path, 0); - fprintf(F, "\n%s %3d ", prefix, get_entity_offset_bits(ent0)); - if (get_type_state(type) == layout_fixed) - fprintf(F, "(%3d) ", get_compound_ent_value_offset_bits(ent, i)); - fprintf(F, "%s", get_entity_name(ent0)); - for (j = 0; j < get_compound_graph_path_length(path); ++j) { - entity *node = get_compound_graph_path_node(path, j); - fprintf(F, ".%s", get_entity_name(node)); - if (is_Array_type(get_entity_owner(node))) - fprintf(F, "[%d]", get_compound_graph_path_array_index(path, j)); - } - fprintf(F, "\t = "); - dump_node_opcode(F, get_compound_ent_value(ent, i)); - } + fprintf(F, "%s compound values:", prefix); + for (i = 0; i < get_compound_ent_n_values(ent); ++i) { + compound_graph_path *path = get_compound_ent_value_path(ent, i); + entity *ent0 = get_compound_graph_path_node(path, 0); + fprintf(F, "\n%s %3d ", prefix, get_entity_offset_bits(ent0)); + if (get_type_state(type) == layout_fixed) + fprintf(F, "(%3d) ", get_compound_ent_value_offset_bits(ent, i)); + fprintf(F, "%s", get_entity_name(ent)); + for (j = 0; j < get_compound_graph_path_length(path); ++j) { + entity *node = get_compound_graph_path_node(path, j); + fprintf(F, ".%s", get_entity_name(node)); + if (is_Array_type(get_entity_owner(node))) + fprintf(F, "[%d]", get_compound_graph_path_array_index(path, j)); + } + fprintf(F, "\t = "); + dump_node_opcode(F, get_compound_ent_value(ent, i)); + } } fprintf(F, "\n"); } @@ -497,11 +588,11 @@ void dump_entity_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned fprintf(F, "\n%s offset: %d", prefix, get_entity_offset_bits(ent)); if (is_Method_type(get_entity_type(ent))) { if (get_entity_irg(ent)) /* can be null */ { - fprintf(F, "\n%s irg = %ld", prefix, get_irg_graph_nr(get_entity_irg(ent))); - if (get_irp_callgraph_state() == irp_callgraph_and_calltree_consistent) { - fprintf(F, "\n%s recursion depth %d", prefix, get_irg_recursion_depth(get_entity_irg(ent))); - fprintf(F, "\n%s loop depth %d", prefix, get_irg_loop_depth(get_entity_irg(ent))); - } + fprintf(F, "\n%s irg = %ld", prefix, get_irg_graph_nr(get_entity_irg(ent))); + if (get_irp_callgraph_state() == irp_callgraph_and_calltree_consistent) { + fprintf(F, "\n%s recursion depth %d", prefix, get_irg_recursion_depth(get_entity_irg(ent))); + fprintf(F, "\n%s loop depth %d", prefix, get_irg_loop_depth(get_entity_irg(ent))); + } } else { fprintf(F, "\n%s irg = NULL", prefix); } @@ -509,6 +600,14 @@ void dump_entity_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned fprintf(F, "\n"); } + if (get_trouts_state()) { + fprintf(F, "%s Entity outs:\n", prefix); + dump_node_list(F, (firm_kind *)ent, prefix, (int(*)(firm_kind *))get_entity_n_accesses, + (ir_node *(*)(firm_kind *, int))get_entity_access, "Accesses"); + dump_node_list(F, (firm_kind *)ent, prefix, (int(*)(firm_kind *))get_entity_n_references, + (ir_node *(*)(firm_kind *, int))get_entity_reference, "References"); + } + if (verbosity & dump_verbosity_accessStats) { #if 0 int n_acc = get_entity_n_accesses(ent); @@ -854,16 +953,33 @@ void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) { if (verbosity & dump_verbosity_typeattrs) { fprintf(F, " supertypes: "); for (i = 0; i < get_class_n_supertypes(tp); ++i) { - type *stp = get_class_supertype(tp, i); - fprintf(F, "\n %s", get_type_name(stp)); + type *stp = get_class_supertype(tp, i); + fprintf(F, "\n %s", get_type_name(stp)); } fprintf(F, "\n subtypes: "); for (i = 0; i < get_class_n_subtypes(tp); ++i) { - type *stp = get_class_subtype(tp, i); - fprintf(F, "\n %s", get_type_name(stp)); + type *stp = get_class_subtype(tp, i); + fprintf(F, "\n %s", get_type_name(stp)); } - fprintf(F, "\n peculiarity: %s", get_peculiarity_string(get_class_peculiarity(tp))); + if (get_irp_inh_transitive_closure_state() != inh_transitive_closure_none) { + type *stp; + fprintf(F, "\n transitive supertypes: "); + for (stp = get_class_trans_supertype_first(tp); + stp; + stp = get_class_trans_supertype_next(tp)) { + fprintf(F, "\n %s", get_type_name(stp)); + } + fprintf(F, "\n transitive subtypes: "); + for (stp = get_class_trans_subtype_first(tp); + stp; + stp = get_class_trans_subtype_next(tp)) { + fprintf(F, "\n %s", get_type_name(stp)); + } + } + + fprintf(F, "\n peculiarity: %s\n", get_peculiarity_string(get_class_peculiarity(tp))); + } break; @@ -878,13 +994,85 @@ void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) { } break; - case tpo_pointer: { + case tpo_array: + if (verbosity & dump_verbosity_typeattrs) { + int i, n_dim; + type *elem_tp = get_array_element_type(tp); + + fprintf(F, "\n array "); + + n_dim = get_array_n_dimensions(tp); + for (i = 0; i < n_dim; ++i) { + ir_node *lower, *upper; + + lower = get_array_lower_bound(tp, i); + upper = get_array_upper_bound(tp, i); + + fprintf(F, "["); + + if (get_irn_op(lower) == op_Const) + fprintf(F, "%ld .. ", get_tarval_long(get_Const_tarval(lower))); + else { + dump_node_opcode(F, lower); + fprintf(F, " %ld .. ", get_irn_node_nr(lower)); + } + + if (get_irn_op(upper) == op_Const) + fprintf(F, "%ld]", get_tarval_long(get_Const_tarval(lower))); + else { + dump_node_opcode(F, upper); + fprintf(F, " %ld]", get_irn_node_nr(upper)); + } + } + fprintf(F, " of <%s (%ld)>", get_type_name(elem_tp), get_type_nr(elem_tp)); + + fprintf(F, "\n order: "); + for (i = 0; i < n_dim; ++i) + fprintf(F, "<%d>", get_array_order(tp, i)); + + fprintf(F, "\n"); + + if (verbosity & dump_verbosity_fields) { + dump_entity_to_file_prefix(F, get_array_element_entity(tp), + " ", verbosity); + } + } + break; + + case tpo_pointer: if (verbosity & dump_verbosity_typeattrs) { type *tt = get_pointer_points_to_type(tp); - fprintf(F, "\n points to %s (%ld)", get_type_name(tt), get_type_nr(tt)); + fprintf(F, "\n points to %s (%ld)\n", get_type_name(tt), get_type_nr(tt)); } + break; - } break; + case tpo_method: + if (verbosity & dump_verbosity_typeattrs) { + fprintf(F, "\n variadicity: %s", get_variadicity_name(get_method_variadicity(tp))); + fprintf(F, "\n return types: %d", get_method_n_ress(tp)); + for (i = 0; i < get_method_n_ress(tp); ++i) { + type *rtp = get_method_res_type(tp, i); + fprintf(F, "\n %s", get_type_name(rtp)); + } + + fprintf(F, "\n parameter types: %d", get_method_n_params(tp)); + for (i = 0; i < get_method_n_params(tp); ++i) { + type *ptp = get_method_param_type(tp, i); + fprintf(F, "\n %s", get_type_name(ptp)); + } + if (get_method_variadicity(tp)) { + fprintf(F, "\n ..."); + } + fprintf(F, "\n"); + } + break; + + case tpo_primitive: + case tpo_id: + case tpo_none: + case tpo_unknown: + fprintf(F, "\n"); + break; default: if (verbosity & dump_verbosity_typeattrs) { @@ -892,6 +1080,23 @@ void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) { } } + fprintf(F, " state: %s,\n", get_type_state_name(get_type_state(tp))); + fprintf(F, " size: %2d Bits,\n", get_type_size_bits(tp)); + fprintf(F, " alignment: %2d Bits,\n", get_type_alignment_bits(tp)); + if (is_atomic_type(tp) || is_Method_type(tp)) + fprintf(F, " mode: %s,\n", get_mode_name(get_type_mode(tp))); + fprintf(F, " dbg info: %p,\n", (void *)get_type_dbg_info(tp)); + + if (get_trouts_state()) { + fprintf(F, "\n Type outs:\n"); + dump_node_list(F, (firm_kind *)tp, " ", (int(*)(firm_kind *))get_type_n_allocs, + (ir_node *(*)(firm_kind *, int))get_type_alloc, "Allocations"); + dump_node_list(F, (firm_kind *)tp, " ", (int(*)(firm_kind *))get_type_n_casts, + (ir_node *(*)(firm_kind *, int))get_type_cast, "Casts"); + dump_type_list(F, tp, " ", get_type_n_pointertypes_to, get_type_pointertype_to, "PointerTpsTo"); + } + + if (verbosity & dump_verbosity_accessStats) { #if 0 int n_all = get_type_n_allocs(tp); @@ -977,3 +1182,31 @@ void dump_types_as_text(unsigned verbosity, const char *suffix) { fclose (F); if (CSV) fclose (CSV); } + + +void dump_globals_as_text(unsigned verbosity, const char *suffix) { + const char *basename; + FILE *F, *CSV = NULL; + type *g = get_glob_type(); + int i, n_mems = get_class_n_members(g); + + basename = irp_prog_name_is_set() ? get_irp_prog_name() : "TextGlobals"; + F = text_open (basename, suffix, "-globals", ".txt"); + + if (verbosity & dump_verbosity_csv) { + CSV = text_open (basename, suffix, "-types", ".csv"); + //fprintf(CSV, "Class, Field, Operation, L0, L1, L2, L3\n"); + } + + for (i = 0; i < n_mems; ++i) { + entity *e = get_class_member(g, i); + + dump_entity_to_file(F, e, verbosity); + if (CSV) { + //dump_entitycsv_to_file_prefix(CSV, e, "", verbosity, ""???); + } + } + + fclose (F); + if (CSV) fclose (CSV); +}