some fixes for xml dumper / still buggy.

[libfirm] / ir / ir / irnode.c

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index 8012f8b..da0cee2 100644 (file)
--- a/ir/ir/irnode.c
+++ b/ir/ir/irnode.c
@@ -14,7 +14,6 @@
 
 #include "irnode_t.h"
 #include "irgraph_t.h"
-#include "xp_help.h"
 #include "irmode_t.h"
 #include "typegmod_t.h"
 #include "array.h"
@@ -79,12 +78,12 @@ get_negated_pnc(int pnc) {
   return 99; /* to shut up gcc */
 }
 
-static const char *pns_name_arr [] = {
+const char *pns_name_arr [] = {
   "initial_exec", "global_store",
   "frame_base", "globals", "args"
 };
 
-static const char *symconst_name_arr [] = {
+const char *symconst_name_arr [] = {
   "type_tag", "size", "linkage_ptr_info"
 };
 
@@ -136,66 +135,17 @@ copy_attrs (ir_node *old, ir_node *new) {
   memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
 }
 
-/* IR-Nodes with attributes */
-int
-ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
-{
-  int printed = 0;
-  ir_node *np = XP_GETARG (ir_node *, 0);
-
-  if (!np) {
-    XPS ("<null ir_node>");
-    return printed;
-  }
-
-  XPF1 ("%I", get_irn_opident(np));
-
-  switch (get_irn_opcode (np)) {       /* node label */
-  case iro_Const:
-    XPF1 ("%I", get_irn_mode(np)->name);
-    XPS (" : ");
-    XPF1 ("%v", get_irn_const_attr);
-    break;
-  case iro_Proj:
-    if (get_irn_mode (np) == mode_b) {
-      XPC (" ");
-      XP (pnc_name_arr[get_irn_proj_attr(np)]);
-    } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
-      XPC (" ");
-      XP (pns_name_arr[get_irn_proj_attr(np)]);
-    } else {
-      XPF1 ("%I", get_irn_mode(np)->name);
-      XPC (" ");
-      XPF1 ("%d", get_irn_proj_attr(np));
-    }
-    break;
-  case iro_SymConst:
-    XPF1 ("%I", get_irn_mode(np)->name);
-    XPC  (" ");
-    XP   (symconst_name_arr[get_irn_symconst_attr(np).num]);
-    XPF1 (" %#N", get_type_ident(get_SymConst_type(np)));
-    break;
-  case iro_Start:              /* don't dump mode of these */
-  case iro_Cond:
-  case iro_Block:
-  case iro_Call:
-  case iro_Jmp:
-  case iro_Return:
-  case iro_End:
-  case iro_Break:
-  case iro_EndReg:
-  case iro_EndExcept:
-  case iro_CallBegin:
-    break;
-  default:
-    XPF1 ("%I", get_irn_mode(np)->name);
-  }
+/** getting some parameters from ir_nodes **/
 
-  return printed;
+int
+is_ir_node (void *thing) {
+  assert(thing);
+  if (get_kind(thing) == k_ir_node)
+    return 1;
+  else
+    return 0;
 }
 
-/** getting some parameters from ir_nodes **/
-
 /* returns the number of predecessors without the block predecessor. */
 INLINE int
 get_irn_arity (const ir_node *node) {
@@ -314,6 +264,14 @@ get_irn_mode (const ir_node *node)
   return node->mode;
 }
 
+INLINE void
+set_irn_mode (ir_node *node, ir_mode *mode)
+{
+  assert (node);
+  node->mode=mode;
+  return;
+}
+
 INLINE modecode
 get_irn_modecode (const ir_node *node)
 {
@@ -2167,6 +2125,7 @@ get_irn_irg(ir_node *node) {
     return node->attr.end.irg;
   } else {
     assert(0 && "no irg attr");
+    return NULL;
   }
 }
 
@@ -2202,6 +2161,9 @@ skip_Tuple (ir_node *node) {
   return node;
 }
 
+/* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
+   than any other approach, as Id chains are resolved and all point to the real node, or
+   all id's are self loops. */
 INLINE ir_node *
 skip_nop (ir_node *node) {
   /* don't assert node !!! */
@@ -2211,8 +2173,17 @@ skip_nop (ir_node *node) {
   /* Don't use get_Id_pred:  We get into an endless loop for
      self-referencing Ids. */
   if (node && (node->op == op_Id) && (node != node->in[0+1])) {
+    ir_node *rem_pred = node->in[0+1];
+    ir_node *res;
+
     assert (get_irn_arity (node) > 0);
-    return node->in[0+1];
+
+    node->in[0+1] = node;
+    res = skip_nop(rem_pred);
+    if (res->op == op_Id) /* self-loop */ return node;
+
+    node->in[0+1] = res;
+    return res;
   } else {
     return node;
   }