BugFix: in newer Firm, keep-alives may be other than Block & Phi

[libfirm] / ir / ir / irnode.c

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index fca414d..44e3ff1 100644 (file)
--- a/ir/ir/irnode.c
+++ b/ir/ir/irnode.c
@@ -30,6 +30,7 @@
 #include "iredges_t.h"
 
 #include "irhooks.h"
+#include "irtools.h"
 
 /* some constants fixing the positions of nodes predecessors
    in the in array */
@@ -40,10 +41,10 @@
 #define END_KEEPALIVE_OFFSET  0
 
 static const char *pnc_name_arr [] = {
-  "False", "Eq", "Lt", "Le",
-  "Gt", "Ge", "Lg", "Leg", "Uo",
-  "Ue", "Ul", "Ule", "Ug", "Uge",
-  "Ne", "True"
+  "pn_Cmp_False", "pn_Cmp_Eq", "pn_Cmp_Lt", "pn_Cmp_Le",
+  "pn_Cmp_Gt", "pn_Cmp_Ge", "pn_Cmp_Lg", "pn_Cmp_Leg",
+  "pn_Cmp_Uo", "pn_Cmp_Ue", "pn_Cmp_Ul", "pn_Cmp_Ule",
+  "pn_Cmp_Ug", "pn_Cmp_Uge", "pn_Cmp_Ne", "pn_Cmp_True"
 };
 
 /**
@@ -465,13 +466,12 @@ void firm_set_irn_section(ir_node *n, struct section *s) {}
 
 
 /* Outputs a unique number for this node */
-long
-get_irn_node_nr(const ir_node *node) {
+long get_irn_node_nr(const ir_node *node) {
   assert(node);
 #ifdef DEBUG_libfirm
   return node->node_nr;
 #else
-  return (long)node;
+  return (long)PTR_TO_INT(node);
 #endif
 }
 
@@ -918,30 +918,6 @@ set_Return_res (ir_node *node, int pos, ir_node *res){
   set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
 }
 
-ir_node *
-get_Raise_mem (ir_node *node) {
-  assert (node->op == op_Raise);
-  return get_irn_n(node, 0);
-}
-
-void
-set_Raise_mem (ir_node *node, ir_node *mem) {
-  assert (node->op == op_Raise);
-  set_irn_n(node, 0, mem);
-}
-
-ir_node *
-get_Raise_exo_ptr (ir_node *node) {
-  assert (node->op == op_Raise);
-  return get_irn_n(node, 1);
-}
-
-void
-set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
-  assert (node->op == op_Raise);
-  set_irn_n(node, 1, exo_ptr);
-}
-
 tarval *(get_Const_tarval)(ir_node *node) {
        return _get_Const_tarval(node);
 }
@@ -1124,42 +1100,6 @@ set_Sel_entity (ir_node *node, entity *ent) {
   node->attr.s.ent = ent;
 }
 
-ir_type *
-get_InstOf_ent (ir_node *node) {
-  assert (node->op = op_InstOf);
-  return (node->attr.io.ent);
-}
-
-void
-set_InstOf_ent (ir_node *node, ir_type *ent) {
-  assert (node->op = op_InstOf);
-  node->attr.io.ent = ent;
-}
-
-ir_node *
-get_InstOf_store (ir_node *node) {
-  assert (node->op = op_InstOf);
-  return (get_irn_n (node, 0));
-}
-
-void
-set_InstOf_store (ir_node *node, ir_node *obj) {
-  assert (node->op = op_InstOf);
-  set_irn_n (node, 0, obj);
-}
-
-ir_node *
-get_InstOf_obj (ir_node *node) {
-  assert (node->op = op_InstOf);
-  return (get_irn_n (node, 1));
-}
-
-void
-set_InstOf_obj (ir_node *node, ir_node *obj) {
-  assert (node->op = op_InstOf);
-  set_irn_n (node, 1, obj);
-}
-
 
 /* For unary and binary arithmetic operations the access to the
    operands can be factored out.  Left is the first, right the
@@ -2076,6 +2016,68 @@ void     set_CopyB_type(ir_node *node, ir_type *data_type) {
   node->attr.copyb.data_type = data_type;
 }
 
+
+ir_type *
+get_InstOf_type (ir_node *node) {
+  assert (node->op = op_InstOf);
+  return node->attr.io.type;
+}
+
+void
+set_InstOf_type (ir_node *node, ir_type *type) {
+  assert (node->op = op_InstOf);
+  node->attr.io.type = type;
+}
+
+ir_node *
+get_InstOf_store (ir_node *node) {
+  assert (node->op = op_InstOf);
+  return get_irn_n(node, 0);
+}
+
+void
+set_InstOf_store (ir_node *node, ir_node *obj) {
+  assert (node->op = op_InstOf);
+  set_irn_n(node, 0, obj);
+}
+
+ir_node *
+get_InstOf_obj (ir_node *node) {
+  assert (node->op = op_InstOf);
+  return get_irn_n(node, 1);
+}
+
+void
+set_InstOf_obj (ir_node *node, ir_node *obj) {
+  assert (node->op = op_InstOf);
+  set_irn_n(node, 1, obj);
+}
+
+/* Returns the memory input of a Raise operation. */
+ir_node *
+get_Raise_mem (ir_node *node) {
+  assert (node->op == op_Raise);
+  return get_irn_n(node, 0);
+}
+
+void
+set_Raise_mem (ir_node *node, ir_node *mem) {
+  assert (node->op == op_Raise);
+  set_irn_n(node, 0, mem);
+}
+
+ir_node *
+get_Raise_exo_ptr (ir_node *node) {
+  assert (node->op == op_Raise);
+  return get_irn_n(node, 1);
+}
+
+void
+set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
+  assert (node->op == op_Raise);
+  set_irn_n(node, 1, exo_ptr);
+}
+
 /* Bound support */
 
 /* Returns the memory input of a Bound operation. */
@@ -2394,6 +2396,14 @@ int (is_irn_constlike)(const ir_node *node) {
   return _is_irn_constlike(node);
 }
 
+/*
+ * Returns non-zero for nodes that are allowed to have keep-alives and
+ * are neither Block nor PhiM.
+ */
+int (is_irn_keep)(const ir_node *node) {
+  return _is_irn_keep(node);
+}
+
 /* Gets the string representation of the jump prediction .*/
 const char *get_cond_jmp_predicate_name(cond_jmp_predicate pred)
 {
@@ -2415,9 +2425,9 @@ void (set_Cond_jmp_pred)(ir_node *cond, cond_jmp_predicate pred) {
   _set_Cond_jmp_pred(cond, pred);
 }
 
-/** the get_type/get_type_attr operation must be always implemented */
-static ir_type *get_Null_type(ir_node *n) {
-  return NULL;
+/** the get_type operation must be always implemented and return a firm type */
+static ir_type *get_Default_type(ir_node *n) {
+  return get_unknown_type();
 }
 
 /* Sets the get_type operation for an ir_op_ops. */
@@ -2431,7 +2441,7 @@ ir_op_ops *firm_set_default_get_type(opcode code, ir_op_ops *ops)
   default:
     /* not allowed to be NULL */
     if (! ops->get_type)
-      ops->get_type = get_Null_type;
+      ops->get_type = get_Default_type;
     break;
   }
   return ops;
@@ -2453,6 +2463,11 @@ static entity *get_SymConst_attr_entity(ir_node *self) {
   return NULL;
 }
 
+/** the get_type_attr operation must be always implemented */
+static ir_type *get_Null_type(ir_node *n) {
+  return firm_unknown_type;
+}
+
 /* Sets the get_type operation for an ir_op_ops. */
 ir_op_ops *firm_set_default_get_type_attr(opcode code, ir_op_ops *ops)
 {