X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firdumptxt.c;h=2b1c8f09863a01d9f10d0e8beb14ddedb1eee8e5;hb=e1c33a238578342a072e1c95ff12eefe6d0acd37;hp=100cd277ba7a13e59012b0a895d6a3b2f7e38238;hpb=ee4e0a8d89e55e24640b8f3066d5e939197b2b73;p=libfirm

diff --git a/ir/ir/irdumptxt.c b/ir/ir/irdumptxt.c
index 100cd277b..2b1c8f098 100644
--- a/ir/ir/irdumptxt.c
+++ b/ir/ir/irdumptxt.c
@@ -92,6 +92,7 @@ int dump_irnode_to_file(FILE *F, ir_node *n) {
   dump_node_opcode(F, n);
   fprintf(F, " %ld\n", get_irn_node_nr(n));
 
+  fprintf(F, "  index: %u\n", get_irn_idx(n));
   if (opt_dump_pointer_values_to_info)
     fprintf (F, "  addr:    %p \n", (void *)n);
   fprintf (F, "  mode:    %s\n", get_mode_name(get_irn_mode(n)));
@@ -189,7 +190,7 @@ int dump_irnode_to_file(FILE *F, ir_node *n) {
     /* not dumped: mature    */
   }  break;
   case iro_Start: {
-    type *tp = get_entity_type(get_irg_entity(get_irn_irg(n)));
+    ir_type *tp = get_entity_type(get_irg_entity(get_irn_irg(n)));
     fprintf(F, "  start of method of type %s \n", get_type_name_ex(tp, &bad));
     for (i = 0; i < get_method_n_params(tp); ++i)
       fprintf(F, "    param %d type: %s \n", i, get_type_name_ex(get_method_param_type(tp, i), &bad));
@@ -231,7 +232,7 @@ int dump_irnode_to_file(FILE *F, ir_node *n) {
     }
   } break;
   case iro_Call: {
-    type *tp = get_Call_type(n);
+    ir_type *tp = get_Call_type(n);
     fprintf(F, "  calling method of type %s \n", get_type_name_ex(tp, &bad));
     if(get_unknown_type() != tp) {
       for (i = 0; i < get_method_n_params(tp); ++i)
@@ -261,14 +262,14 @@ int dump_irnode_to_file(FILE *F, ir_node *n) {
   } break;
   case iro_Return: {
     if (!get_interprocedural_view()) {
-      type *tp = get_entity_type(get_irg_entity(get_irn_irg(n)));
+      ir_type *tp = get_entity_type(get_irg_entity(get_irn_irg(n)));
       fprintf(F, "  return in method of type %s \n", get_type_name_ex(tp, &bad));
       for (i = 0; i < get_method_n_ress(tp); ++i)
         fprintf(F, "    res %d type: %s \n", i, get_type_name_ex(get_method_res_type(tp, i), &bad));
     }
   } break;
   case iro_Const: {
-    type *tp = get_Const_type(n);
+    ir_type *tp = get_Const_type(n);
     assert(tp != firm_none_type);
     fprintf(F, "  Const of type %s \n", get_type_name_ex(get_Const_type(n), &bad));
   } break;
@@ -288,11 +289,16 @@ int dump_irnode_to_file(FILE *F, ir_node *n) {
       fprintf(F, "  type: ");
       dump_type_to_file(F, get_SymConst_type(n), dump_verbosity_onlynames);
       break;
-    case symconst_size:
+    case symconst_type_size:
       fprintf(F, "  kind: size\n");
       fprintf(F, "  type: ");
       dump_type_to_file(F, get_SymConst_type(n), dump_verbosity_onlynames);
       break;
+    case symconst_type_align:
+      fprintf(F, "  kind: alignment\n");
+      fprintf(F, "  type: ");
+      dump_type_to_file(F, get_SymConst_type(n), dump_verbosity_onlynames);
+      break;
     }
     fprintf(F, "  type of value: %s \n", get_type_name_ex(get_SymConst_value_type(n), &bad));
   } break;
@@ -360,7 +366,7 @@ int addr_is_alloc(ir_node *acc) {
   if (is_memop(acc)) {
     addr = get_memop_ptr(acc);
   } else {
-    assert(get_irn_op(acc) == op_Call);
+    assert(is_Call(acc));
     addr = get_Call_ptr(acc);
   }
 
@@ -438,9 +444,9 @@ static void dump_node_list(FILE *F, firm_kind *k, char *prefix,
  *  "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),
+static void dump_type_list(FILE *F, ir_type *tp, char *prefix,
+			   int (*get_n_types)(ir_type *tp),
+			   ir_type *(*get_type)(ir_type *tp, int pos),
 			   char *name) {
   int i, n_nodes = get_n_types(tp);
   char *comma = "";
@@ -458,10 +464,9 @@ static void dump_type_list(FILE *F, type *tp, char *prefix,
   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;
-  type *owner, *type;
+  ir_type *owner, *type;
 
   assert(is_entity(ent));
   owner = get_entity_owner(ent);
@@ -518,52 +523,39 @@ void    dump_entity_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned
       }
     }
 
-    fprintf(F, "%s  allocation:  ", prefix);
-    switch (get_entity_allocation(ent)) {
-      X(allocation_dynamic);
-      X(allocation_automatic);
-      X(allocation_static);
-      X(allocation_parameter);
-    }
-
-    fprintf(F, "\n%s  visibility:  ", prefix);
-    switch (get_entity_visibility(ent)) {
-      X(visibility_local);
-      X(visibility_external_visible);
-      X(visibility_external_allocated);
-    }
-
-    fprintf(F, "\n%s  variability: ", prefix);
-    switch (get_entity_variability(ent)) {
-      X(variability_uninitialized);
-      X(variability_initialized);
-      X(variability_part_constant);
-      X(variability_constant);
-    }
+    fprintf(F, "%s  allocation:  %s", prefix, get_allocation_name(get_entity_allocation(ent)));
+    fprintf(F, "\n%s  visibility:  %s", prefix, get_visibility_name(get_entity_visibility(ent)));
+    fprintf(F, "\n%s  variability: %s", prefix, get_variability_name(get_entity_variability(ent)));
 
     if (is_Method_type(get_entity_type(ent))) {
       unsigned mask = get_entity_additional_properties(ent);
-      unsigned cc   = get_entity_calling_convention(ent);
+      unsigned cc   = get_method_calling_convention(get_entity_type(ent));
+      ir_graph *irg = get_entity_irg(ent);
+
+      if (irg) {
+        fprintf(F, "\n%s  estimated node count: %u", prefix, get_irg_estimated_node_cnt(irg));
+        fprintf(F, "\n%s  maximum node index:   %u", prefix, get_irg_last_idx(irg));
+      }
 
       if (mask) {
         fprintf(F, "\n%s  additional prop: ", prefix);
 
-        if (mask & irg_const_function)    fprintf(F, "const_function, ");
-        if (mask & irg_pure_function)     fprintf(F, "pure_function, ");
-        if (mask & irg_noreturn_function) fprintf(F, "noreturn_function, ");
-        if (mask & irg_nothrow_function)  fprintf(F, "nothrow_function, ");
-        if (mask & irg_naked_function)    fprintf(F, "naked_function, ");
+        if (mask & mtp_property_const)    fprintf(F, "const_function, ");
+        if (mask & mtp_property_pure)     fprintf(F, "pure_function, ");
+        if (mask & mtp_property_noreturn) fprintf(F, "noreturn_function, ");
+        if (mask & mtp_property_nothrow)  fprintf(F, "nothrow_function, ");
+        if (mask & mtp_property_naked)    fprintf(F, "naked_function, ");
       }
       fprintf(F, "\n%s  calling convention: ", prefix);
-      if (cc & irg_cc_reg_param) fprintf(F, "regparam, ");
-      if (cc & irg_cc_this_call) fprintf(F, "thiscall, ");
+      if (cc & cc_reg_param) fprintf(F, "regparam, ");
+      if (cc & cc_this_call) fprintf(F, "thiscall, ");
       if (IS_CDECL(cc))
         fprintf(F, "cdecl");
       else if (IS_STDCALL(cc))
         fprintf(F, "stdcall");
       else {
-        fprintf(F, (cc & irg_cc_last_on_top) ? "last param on top, " : "first param on top, ");
-        fprintf(F, (cc & irg_cc_callee_clear_stk) ? "callee clear stack" : "caller clear stack");
+        fprintf(F, (cc & cc_last_on_top) ? "last param on top, " : "first param on top, ");
+        fprintf(F, (cc & cc_callee_clear_stk) ? "callee clear stack" : "caller clear stack");
       }
     }
 
@@ -610,13 +602,8 @@ void    dump_entity_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned
   }
 
   if (verbosity & dump_verbosity_entattrs) {
-    fprintf(F, "%s  volatility:  ", prefix);
-    switch (get_entity_volatility(ent)) {
-      X(volatility_non_volatile);
-      X(volatility_is_volatile);
-    }
-
-    fprintf(F, "\n%s  peculiarity: %s", prefix, get_peculiarity_string(get_entity_peculiarity(ent)));
+    fprintf(F, "%s  volatility:  %s", prefix, get_volatility_name(get_entity_volatility(ent)));
+    fprintf(F, "\n%s  peculiarity: %s", prefix, get_peculiarity_name(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 bits, %d bytes", prefix, get_entity_offset_bits(ent), get_entity_offset_bytes(ent));
     if (is_Method_type(get_entity_type(ent))) {
@@ -756,7 +743,6 @@ void    dump_entity_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned
   }
 
 }
-#undef X
 
 void    dump_entity_to_file (FILE *F, entity *ent, unsigned verbosity) {
   dump_entity_to_file_prefix (F, ent, "", verbosity);
@@ -868,7 +854,7 @@ void    dump_entitycsv_to_file_prefix (FILE *F, entity *ent, char *prefix, unsig
 }
 
 /* A fast hack to dump a csv. */
-void dump_typecsv_to_file(FILE *F, type *tp, dump_verbosity verbosity, const char *comma) {
+void dump_typecsv_to_file(FILE *F, ir_type *tp, dump_verbosity verbosity, const char *comma) {
   int i;
   char buf[1024 + 10];
   if (!is_Class_type(tp)) return;   // we also want array types. Stupid, these are classes in java.
@@ -953,7 +939,7 @@ void dump_typecsv_to_file(FILE *F, type *tp, dump_verbosity verbosity, const cha
   }
 }
 
-void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) {
+void dump_type_to_file (FILE *F, ir_type *tp, dump_verbosity verbosity) {
   int i;
 
   if ((is_Class_type(tp))       && (verbosity & dump_verbosity_noClassTypes)) return;
@@ -986,17 +972,17 @@ 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);
+        ir_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);
+        ir_type *stp = get_class_subtype(tp, i);
         fprintf(F, "\n    %s", get_type_name(stp));
       }
 
       if (get_irp_inh_transitive_closure_state() != inh_transitive_closure_none) {
-        type *stp;
+        ir_type *stp;
         fprintf(F, "\n  transitive supertypes: ");
         for (stp = get_class_trans_supertype_first(tp);
 	           stp;
@@ -1011,8 +997,15 @@ void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) {
         }
       }
 
-      fprintf(F, "\n  peculiarity: %s\n", get_peculiarity_string(get_class_peculiarity(tp)));
-
+      fprintf(F, "\n  peculiarity: %s\n", get_peculiarity_name(get_class_peculiarity(tp)));
+      fprintf(F, "\n  flags:       ");
+      if (is_class_final(tp))
+        fprintf(F, "final, ");
+      if (is_class_interface(tp))
+        fprintf(F, "interface, ");
+      if (is_class_abstract(tp))
+        fprintf(F, "abstract, ");
+      fprintf(F, "\n");
     }
     break;
 
@@ -1030,7 +1023,7 @@ void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) {
   case tpo_array:
     if (verbosity & dump_verbosity_typeattrs) {
       int i, n_dim;
-      type *elem_tp = get_array_element_type(tp);
+      ir_type *elem_tp = get_array_element_type(tp);
 
       fprintf(F, "\n  array ");
 
@@ -1074,7 +1067,7 @@ void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) {
 
   case tpo_pointer:
     if (verbosity & dump_verbosity_typeattrs) {
-      type *tt = get_pointer_points_to_type(tp);
+      ir_type *tt = get_pointer_points_to_type(tp);
       fprintf(F, "\n  points to %s (%ld)\n", get_type_name(tt), get_type_nr(tt));
     }
     break;
@@ -1084,13 +1077,13 @@ void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) {
       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);
+        ir_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);
+        ir_type *ptp = get_method_param_type(tp, i);
         fprintf(F, "\n    %s", get_type_name(ptp));
       }
       if (get_method_variadicity(tp)) {
@@ -1183,7 +1176,7 @@ void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) {
   fprintf(F, "\n\n");
 }
 
-void dump_type(type *tp) {
+void dump_type(ir_type *tp) {
   dump_type_to_file (stdout, tp, dump_verbosity_max);
 }
 
@@ -1202,7 +1195,7 @@ void dump_types_as_text(unsigned verbosity, const char *suffix) {
   }
 
   for (i = 0; i < n_types; ++i) {
-    type *t = get_irp_type(i);
+    ir_type *t = get_irp_type(i);
 
     //if (is_jack_rts_class(t)) continue;
 
@@ -1220,7 +1213,7 @@ void dump_types_as_text(unsigned verbosity, const char *suffix) {
 void dump_globals_as_text(unsigned verbosity, const char *suffix) {
   const char *basename;
   FILE *F, *CSV = NULL;
-  type *g = get_glob_type();
+  ir_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";