X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firdumptxt.c;h=5a0428ba793baaa894ec0850be02fe072db1eb89;hb=76a6c3b40390427bc516a943316642bb57daa465;hp=7d6a60999f63e6b38059113353ea3c18b4ee3571;hpb=3cf379f70cdce611cd096a62a8f1b31bea84aab1;p=libfirm

diff --git a/ir/ir/irdumptxt.c b/ir/ir/irdumptxt.c
index 7d6a60999..5a0428ba7 100644
--- a/ir/ir/irdumptxt.c
+++ b/ir/ir/irdumptxt.c
@@ -31,6 +31,7 @@
 #include "entity_t.h"
 #include "trouts.h"
 #include "irgwalk.h"
+#include "tv.h"
 
 #include "field_temperature.h"
 
@@ -125,7 +126,7 @@ int dump_irnode_to_file(FILE *F, ir_node *n) {
 
   if ((get_irp_ip_view_state() != ip_view_no)
       && (get_irn_opcode(n) == iro_Filter || get_irn_opcode(n) == iro_Block)) {
-    fprintf(F, "  inter arity: %d", get_irn_inter_arity(n));
+    fprintf(F, "  inter arity: %d\n", get_irn_inter_arity(n));
     fprintf(F, "  inter pred nodes: \n");
     for ( i = 0; i < get_irn_inter_arity(n); ++i) {
       fprintf(F, "     %d: %s ", i, is_intra_backedge(n, i) ? "be" : "  ");
@@ -150,20 +151,20 @@ int dump_irnode_to_file(FILE *F, ir_node *n) {
     fprintf(F, "\n");
   }
 
-  /* Loop node   Someone else please tell me what's wrong ...
+  /* 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",
+    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_Block: {
-    fprintf(F, "  block visited: %ld", get_Block_block_visited(n));
-    fprintf(F, "  dominator info: not implemented\n");
+    fprintf(F, "  block visited: %ld\n", get_Block_block_visited(n));
+    fprintf(F, "  dominator info: output not implemented\n");
     /* not dumped: graph_arr */
     /* not dumped: mature    */
   }  break;
@@ -199,7 +200,8 @@ int dump_irnode_to_file(FILE *F, ir_node *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));
+      fprintf(F, "    from entity %s (%ld)\n", get_entity_name(ent), get_entity_nr(ent));
+      fprintf(F, "    of type %s\n", get_type_name_ex(get_entity_owner(ent), &bad));
     }
     else {
       fprintf(F, "  <NULL entity>\n");
@@ -245,7 +247,7 @@ int dump_irnode_to_file(FILE *F, ir_node *n) {
   } break;
   case iro_Const: {
     type *tp = get_Const_type(n);
-    assert(tp != none_type);
+    assert(tp != firm_none_type);
     fprintf(F, "  Const of type %s \n", get_type_name_ex(get_Const_type(n), &bad));
   } break;
   case iro_SymConst: {
@@ -286,9 +288,9 @@ int dump_irnode_to_file(FILE *F, ir_node *n) {
   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_typeinfo_type(n) != none_type)
+  if (get_irg_typeinfo_state(get_irn_irg(n)) == ir_typeinfo_consistent  ||
+      get_irg_typeinfo_state(get_irn_irg(n)) == ir_typeinfo_inconsistent  )
+    if (get_irn_typeinfo_type(n) != firm_none_type)
       fprintf (F, "  Analysed type: %s\n", get_type_name_ex(get_irn_typeinfo_type(n), &bad));
 
   return bad;
@@ -366,8 +368,9 @@ int addr_is_alloc(ir_node *acc) {
       break;
 
     default:
-      DDMN(addr);
-      assert(0 && "unexpected address node");
+      //DDMN(addr);
+      //assert(0 && "unexpected address node");
+      ;
     }
     addr_op = get_irn_opcode(addr);
   }
@@ -396,7 +399,7 @@ void    dump_entity_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned
     fprintf(F, "%s  type:  %s (%ld)\n", prefix, get_type_name(type),  get_type_nr(type));
     fprintf(F, "%s  owner: %s (%ld)\n", prefix, get_type_name(owner), get_type_nr(owner));
 
-    if (is_class_type(get_entity_owner(ent))) {
+    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) {
@@ -445,7 +448,7 @@ void    dump_entity_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned
   } else {  /* no entattrs */
     fprintf(F, "%s(%3d) %*s: %s", prefix,
 	    get_entity_offset_bits(ent), -40, get_type_name(get_entity_type(ent)), get_entity_name(ent));
-    if (is_method_type(get_entity_type(ent))) fprintf(F, "(...)");
+    if (is_Method_type(get_entity_type(ent))) fprintf(F, "(...)");
 
     if (verbosity & dump_verbosity_accessStats) {
       if (get_entity_allocation(ent) == allocation_static) fprintf(F, " (stat)");
@@ -458,26 +461,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");
     }
@@ -493,21 +496,22 @@ void    dump_entity_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned
     fprintf(F, "\n%s  peculiarity: %s", prefix, get_peculiarity_string(get_entity_peculiarity(ent)));
     fprintf(F, "\n%s  ld_name: %s", prefix, ent->ld_name ? get_entity_ld_name(ent) : "no yet set");
     fprintf(F, "\n%s  offset:  %d", prefix, get_entity_offset_bits(ent));
-    if (is_method_type(get_entity_type(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);
+	      fprintf(F, "\n%s  irg = NULL", prefix);
       }
     }
     fprintf(F, "\n");
   }
 
   if (verbosity & dump_verbosity_accessStats) {
+#if 0
     int n_acc = get_entity_n_accesses(ent);
     int max_depth = 0;
     int max_L_freq = -1;
@@ -608,6 +612,16 @@ void    dump_entity_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned
 
     /* free allocated space */
     free(L_freq);
+#endif
+    if (get_trouts_state() != outs_none) {
+      if (is_Method_type(get_entity_type(ent))) {
+	fprintf(F, "%s  Estimated #Calls:    %lf\n", prefix, get_entity_estimated_n_calls(ent));
+	fprintf(F, "%s  Estimated #dynCalls: %lf\n", prefix, get_entity_estimated_n_calls(ent));
+      } else {
+	fprintf(F, "%s  Estimated #Loads:  %lf\n", prefix, get_entity_estimated_n_loads(ent));
+	fprintf(F, "%s  Estimated #Stores: %lf\n", prefix, get_entity_estimated_n_stores(ent));
+      }
+    }
   }
 
 }
@@ -624,7 +638,8 @@ void dump_entity (entity *ent) {
 
 void    dump_entitycsv_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned verbosity,
 				       int *max_disp, int disp[], const char *comma) {
-  int i, max_depth = 0;
+
+#if 0   /* Outputs loop depth of all occurences. */
   int n_acc = get_entity_n_accesses(ent);
   int max_L_freq = -1;
   int max_S_freq = -1;
@@ -634,6 +649,7 @@ void    dump_entitycsv_to_file_prefix (FILE *F, entity *ent, char *prefix, unsig
   int *S_freq;
   int *LA_freq;
   int *SA_freq;
+  int i, max_depth = 0;
 
   /* Find maximal depth */
   for (i = 0; i < n_acc; ++i) {
@@ -642,7 +658,7 @@ void    dump_entitycsv_to_file_prefix (FILE *F, entity *ent, char *prefix, unsig
     max_depth = (depth > max_depth) ? depth : max_depth ;
   }
 
-  L_freq = xcalloc(4 * max_depth, sizeof(L_freq[0]));
+  L_freq = xcalloc(4 * (max_depth+1), sizeof(L_freq[0]));
 
   S_freq  = L_freq + 1*max_depth;
   LA_freq = L_freq + 2*max_depth;
@@ -651,7 +667,7 @@ void    dump_entitycsv_to_file_prefix (FILE *F, entity *ent, char *prefix, unsig
   for (i = 0; i < n_acc; ++i) {
     ir_node *acc = get_entity_access(ent, i);
     int depth = get_weighted_loop_depth(acc);
-    assert(depth < max_depth);
+    assert(depth <= max_depth);
     if ((get_irn_op(acc) == op_Load) || (get_irn_op(acc) == op_Call)) {
       L_freq[depth]++;
       max_L_freq = (depth > max_L_freq) ? depth : max_L_freq;
@@ -698,35 +714,57 @@ void    dump_entitycsv_to_file_prefix (FILE *F, entity *ent, char *prefix, unsig
     fprintf(F, "\n");
   }
   free(L_freq);
+#endif
+
+  if (get_entity_allocation(ent) != allocation_static) {
+    if (is_Method_type(get_entity_type(ent))) return;
+
+    /* Output the entity name. */
+    fprintf(F, "%s%-40s ", prefix, get_entity_ld_name(ent));
+
+    if (get_trouts_state() != outs_none) {
+      if (is_Method_type(get_entity_type(ent))) {
+	//fprintf(F, "%s  Estimated #Calls:    %lf\n", prefix, get_entity_estimated_n_calls(ent));
+	//fprintf(F, "%s  Estimated #dynCalls: %lf\n", prefix, get_entity_estimated_n_calls(ent));
+      } else {
+	fprintf(F, "%6.2lf ", get_entity_estimated_n_loads(ent));
+	fprintf(F, "%6.2lf", get_entity_estimated_n_stores(ent));
+      }
+    }
+
+    fprintf(F, "\n");
+  }
 }
 
 /* A fast hack to dump a csv. */
 void dump_typecsv_to_file(FILE *F, type *tp, dump_verbosity verbosity, const char *comma) {
-  int max_freq = -1;
-  int max_disp = -1;
-  int *freq, *disp; /* Accumulated accesses to static members: dispatch table. */
-
-  if (!is_class_type(tp)) return;
+  int i;
+  char buf[1024 + 10];
+  if (!is_Class_type(tp)) return;   // we also want array types. Stupid, these are classes in java.
 
   if (verbosity & dump_verbosity_accessStats) {
-    int i, n_all = get_type_n_allocations(tp);
-    int max_depth = 0;
 
+#if 0      /* Outputs loop depth of all occurences. */
+    int max_freq = -1;
+    int max_disp = -1;
+    int *freq, *disp; /* Accumulated accesses to static members: dispatch table. */
+    int n_all = get_type_n_allocs(tp);
+    int max_depth = 0;
     /* Find maximal depth */
     for (i = 0; i < n_all; ++i) {
-      ir_node *all = get_type_allocation(tp, i);
+      ir_node *all = get_type_alloc(tp, i);
       int depth = get_weighted_loop_depth(all);
       max_depth = (depth > max_depth) ? depth : max_depth ;
     }
 
-    freq = xcalloc(2 * max_depth, sizeof(freq[0]));
+    freq = xcalloc(2 * (max_depth+1), sizeof(freq[0]));
 
     disp = freq + max_depth;
 
     for (i = 0; i < n_all; ++i) {
-      ir_node *all = get_type_allocation(tp, i);
+      ir_node *all = get_type_alloc(tp, i);
       int depth = get_weighted_loop_depth(all);
-      assert(depth < max_depth);
+      assert(depth <= max_depth);
       freq[depth]++;
       max_freq = (depth > max_freq) ? depth : max_freq;
       assert(get_irn_op(all) == op_Alloc);
@@ -744,36 +782,57 @@ void dump_typecsv_to_file(FILE *F, type *tp, dump_verbosity verbosity, const cha
 
     for (i = 0; i < get_class_n_members(tp); ++i) {
       entity *mem = get_class_member(tp, i);
-      if (((verbosity & dump_verbosity_methods) &&  is_method_type(get_entity_type(mem))) ||
-	      ((verbosity & dump_verbosity_fields)  && !is_method_type(get_entity_type(mem)))   ) {
-	    dump_entitycsv_to_file_prefix(F, mem, "    ", verbosity, &max_disp, disp, comma);
+      if (((verbosity & dump_verbosity_methods) &&  is_Method_type(get_entity_type(mem))) ||
+	  ((verbosity & dump_verbosity_fields)  && !is_Method_type(get_entity_type(mem)))   ) {
+	if (!((verbosity & dump_verbosity_nostatic) && (get_entity_allocation(mem) == allocation_static))) {
+	  dump_entitycsv_to_file_prefix(F, mem, "    ", verbosity, &max_disp, disp, comma);
+	}
       }
     }
 
     if (max_disp >= 0) {
       fprintf(F, "%s__disp_tab%s Load", get_type_name(tp), comma);
       for (i = 0; i <= max_disp; ++i) {
-	    fprintf(F, "%s %d", comma, disp[i]);
+	      fprintf(F, "%s %d", comma, disp[i]);
       }
       fprintf(F, "\n");
     }
 
     /* free allocated space */
     free(freq);
+#endif
+
+#define DISP_TAB_SUFFIX "__disp_tab"
+    if (get_trouts_state() != outs_none) {
+      assert(strlen(get_type_name(tp)) < 1024);
+      fprintf(F, "%-44s %6.2lf  -1.00\n", get_type_name(tp), get_type_estimated_n_instances(tp));
+      sprintf(buf, "%s%s", get_type_name(tp), DISP_TAB_SUFFIX);
+      fprintf(F, "%-44s %6.2lf   0.00\n", buf, get_class_estimated_n_dyncalls(tp));
+    }
+
+    for (i = 0; i < get_class_n_members(tp); ++i) {
+      entity *mem = get_class_member(tp, i);
+      if (((verbosity & dump_verbosity_methods) &&  is_Method_type(get_entity_type(mem))) ||
+	  ((verbosity & dump_verbosity_fields)  && !is_Method_type(get_entity_type(mem)))   ) {
+	if (!((verbosity & dump_verbosity_nostatic) && (get_entity_allocation(mem) == allocation_static))) {
+	  dump_entitycsv_to_file_prefix(F, mem, "    ", verbosity, NULL, 0, 0);
+	}
+      }
+    }
   }
 }
 
 void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) {
   int i;
 
-  if ((is_class_type(tp))       && (verbosity & dump_verbosity_noClassTypes)) return;
-  if ((is_struct_type(tp))      && (verbosity & dump_verbosity_noStructTypes)) return;
-  if ((is_union_type(tp))       && (verbosity & dump_verbosity_noUnionTypes)) return;
-  if ((is_array_type(tp))       && (verbosity & dump_verbosity_noArrayTypes)) return;
-  if ((is_pointer_type(tp))     && (verbosity & dump_verbosity_noPointerTypes)) return;
-  if ((is_method_type(tp))      && (verbosity & dump_verbosity_noMethodTypes)) return;
-  if ((is_primitive_type(tp))   && (verbosity & dump_verbosity_noPrimitiveTypes)) return;
-  if ((is_enumeration_type(tp)) && (verbosity & dump_verbosity_noEnumerationTypes)) return;
+  if ((is_Class_type(tp))       && (verbosity & dump_verbosity_noClassTypes)) return;
+  if ((is_Struct_type(tp))      && (verbosity & dump_verbosity_noStructTypes)) return;
+  if ((is_Union_type(tp))       && (verbosity & dump_verbosity_noUnionTypes)) return;
+  if ((is_Array_type(tp))       && (verbosity & dump_verbosity_noArrayTypes)) return;
+  if ((is_Pointer_type(tp))     && (verbosity & dump_verbosity_noPointerTypes)) return;
+  if ((is_Method_type(tp))      && (verbosity & dump_verbosity_noMethodTypes)) return;
+  if ((is_Primitive_type(tp))   && (verbosity & dump_verbosity_noPrimitiveTypes)) return;
+  if ((is_Enumeration_type(tp)) && (verbosity & dump_verbosity_noEnumerationTypes)) return;
 
   fprintf(F, "%s type %s (%ld)", get_tpop_name(get_type_tpop(tp)), get_type_name(tp), get_type_nr(tp));
   if (verbosity & dump_verbosity_onlynames) { fprintf(F, "\n"); return; }
@@ -786,21 +845,23 @@ void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) {
     }
     for (i = 0; i < get_class_n_members(tp); ++i) {
       entity *mem = get_class_member(tp, i);
-      if (((verbosity & dump_verbosity_methods) &&  is_method_type(get_entity_type(mem))) ||
-	      ((verbosity & dump_verbosity_fields)  && !is_method_type(get_entity_type(mem)))   ) {
-	    dump_entity_to_file_prefix(F, mem, "    ", verbosity);
+      if (((verbosity & dump_verbosity_methods) &&  is_Method_type(get_entity_type(mem))) ||
+	  ((verbosity & dump_verbosity_fields)  && !is_Method_type(get_entity_type(mem)))   ) {
+	if (!((verbosity & dump_verbosity_nostatic) && (get_entity_allocation(mem) == allocation_static))) {
+	  dump_entity_to_file_prefix(F, mem, "    ", 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)));
@@ -813,18 +874,68 @@ void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) {
     for (i = 0; i < get_compound_n_members(tp); ++i) {
       entity *mem = get_compound_member(tp, i);
       if (verbosity & dump_verbosity_fields) {
-	    dump_entity_to_file_prefix(F, mem, "    ", verbosity);
+	      dump_entity_to_file_prefix(F, mem, "    ", verbosity);
+      }
+    }
+    break;
+
+  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: {
+  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));
     }
+    break;
 
-  } break;
+  case tpo_primitive:
+  case tpo_id:
+  case tpo_none:
+  case tpo_unknown:
+    break;
 
   default:
     if (verbosity & dump_verbosity_typeattrs) {
@@ -832,25 +943,33 @@ 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))
+    fprintf(F, "  mode:      %s,\n",  get_mode_name(get_type_mode(tp)));
+  fprintf(F, "  dbg info:  %p,",  (void *)get_type_dbg_info(tp));
+
   if (verbosity & dump_verbosity_accessStats) {
-    int n_all = get_type_n_allocations(tp);
+#if 0
+    int n_all = get_type_n_allocs(tp);
     int max_depth = 0;
     int max_freq = -1;
     int *freq;
 
     /* Find maximal depth */
     for (i = 0; i < n_all; ++i) {
-      ir_node *all = get_type_allocation(tp, i);
+      ir_node *all = get_type_alloc(tp, i);
       int depth = get_weighted_loop_depth(all);
       max_depth = (depth > max_depth) ? depth : max_depth ;
     }
 
-    freq = xcalloc(max_depth, sizeof(freq[0]));
+    freq = xcalloc(max_depth+1, sizeof(freq[0]));
 
     for (i = 0; i < n_all; ++i) {
-      ir_node *all = get_type_allocation(tp, i);
+      ir_node *all = get_type_alloc(tp, i);
       int depth = get_weighted_loop_depth(all);
-      assert(depth < max_depth);
+      assert(depth <= max_depth);
       freq[depth]++;
       max_freq = (depth > max_freq) ? depth : max_freq;
       assert(get_irn_op(all) == op_Alloc);
@@ -868,6 +987,17 @@ void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) {
     }
 
     free(freq);
+#endif
+    if (get_trouts_state() != outs_none) {
+      fprintf(F, "  Estimated #Instances: %lf\n", get_type_estimated_n_instances(tp));
+      if (is_Class_type(tp)) {
+	fprintf(F, "  Estimated #dyn Calls: %lf\n", get_class_estimated_n_dyncalls(tp));
+	fprintf(F, "  Estimated #Upcasts:   %lf (#CastOps: %d)\n", get_class_estimated_n_upcasts(tp), get_class_n_upcasts(tp));
+	fprintf(F, "  Estimated #Downcasts: %lf (#CastOps: %d)\n", get_class_estimated_n_downcasts(tp), get_class_n_downcasts(tp));
+	assert(get_class_n_upcasts(tp) + get_class_n_downcasts(tp) == get_type_n_casts(tp));
+      }
+    }
+
   }
 
   fprintf(F, "\n\n");
@@ -880,7 +1010,7 @@ void dump_type(type *tp) {
 
 void dump_types_as_text(unsigned verbosity, const char *suffix) {
   const char *basename;
-  FILE *F, *CSV;
+  FILE *F, *CSV = NULL;
   int i, n_types = get_irp_n_types();
 
   basename = irp_prog_name_is_set() ? get_irp_prog_name() : "TextTypes";
@@ -894,14 +1024,42 @@ void dump_types_as_text(unsigned verbosity, const char *suffix) {
   for (i = 0; i < n_types; ++i) {
     type *t = get_irp_type(i);
 
-    if (is_jack_rts_class(t)) continue;
+    //if (is_jack_rts_class(t)) continue;
 
     dump_type_to_file(F, t, verbosity);
-    if (verbosity & dump_verbosity_csv) {
+    if (CSV) {
       dump_typecsv_to_file(CSV, t, verbosity, "");
     }
   }
 
   fclose (F);
-  if (verbosity & dump_verbosity_csv) fclose (CSV);
+  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);
 }