- add an extra filed for the bit offset\n- renamed access functions\n- renamed entity...

[libfirm] / ir / ir / irnode.c

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index 414b8a2..df556c2 100644 (file)
--- a/ir/ir/irnode.c
+++ b/ir/ir/irnode.c
@@ -888,6 +888,25 @@ void set_End_keepalives(ir_node *end, int n, ir_node *in[]) {
     edges_notify_edge(end, END_KEEPALIVE_OFFSET + i, NULL, end->in[1 + END_KEEPALIVE_OFFSET + i], irg);
   }
 }
+/* Set new keep-alives from old keep-alives, skipping irn */
+void remove_End_keepalive(ir_node *end, ir_node *irn) {
+  int     n = get_End_n_keepalives(end);
+  ir_node **in;
+  int     i, idx;
+
+  NEW_ARR_A(ir_node *, in, n);
+
+  for (idx = i = 0; i < n; ++i) {
+    ir_node *old_ka = get_End_keepalive(end, i);
+
+    /* skip irn */
+    if (old_ka != irn)
+      in[idx++] = old_ka;
+  }
+
+  /* set new keep-alives */
+  set_End_keepalives(end, idx, in);
+}
 
 void
 free_End (ir_node *end) {
@@ -1083,41 +1102,35 @@ set_SymConst_type (ir_node *node, ir_type *tp) {
 
 ident *
 get_SymConst_name (ir_node *node) {
-  assert(   (node->op == op_SymConst)
-          && (get_SymConst_kind(node) == symconst_addr_name));
+  assert(node->op == op_SymConst && SYMCONST_HAS_ID(get_SymConst_kind(node)));
   return node->attr.symc.sym.ident_p;
 }
 
 void
 set_SymConst_name (ir_node *node, ident *name) {
-  assert(   (node->op == op_SymConst)
-          && (get_SymConst_kind(node) == symconst_addr_name));
+  assert(node->op == op_SymConst && SYMCONST_HAS_ID(get_SymConst_kind(node)));
   node->attr.symc.sym.ident_p = name;
 }
 
 
 /* Only to access SymConst of kind symconst_addr_ent.  Else assertion: */
 entity   *get_SymConst_entity (ir_node *node) {
-  assert(   (node->op == op_SymConst)
-          && (get_SymConst_kind (node) == symconst_addr_ent));
+  assert(node->op == op_SymConst && SYMCONST_HAS_ENT(get_SymConst_kind(node)));
   return node->attr.symc.sym.entity_p;
 }
 
 void     set_SymConst_entity (ir_node *node, entity *ent) {
-  assert(   (node->op == op_SymConst)
-          && (get_SymConst_kind(node) == symconst_addr_ent));
+  assert(node->op == op_SymConst && SYMCONST_HAS_ENT(get_SymConst_kind(node)));
   node->attr.symc.sym.entity_p  = ent;
 }
 
 ir_enum_const *get_SymConst_enum (ir_node *node) {
-  assert(   (node->op == op_SymConst)
-          && (get_SymConst_kind (node) == symconst_enum_const));
+  assert(node->op == op_SymConst && SYMCONST_HAS_ENUM(get_SymConst_kind(node)));
   return node->attr.symc.sym.enum_p;
 }
 
 void           set_SymConst_enum (ir_node *node, ir_enum_const *ec) {
-  assert(   (node->op == op_SymConst)
-          && (get_SymConst_kind(node) == symconst_enum_const));
+  assert(node->op == op_SymConst && SYMCONST_HAS_ENUM(get_SymConst_kind(node)));
   node->attr.symc.sym.enum_p  = ec;
 }
 
@@ -1683,14 +1696,14 @@ set_Load_mode (ir_node *node, ir_mode *mode) {
   node->attr.load.load_mode = mode;
 }
 
-ent_volatility
+ir_volatility
 get_Load_volatility (ir_node *node) {
   assert(node->op == op_Load);
   return node->attr.load.volatility;
 }
 
 void
-set_Load_volatility (ir_node *node, ent_volatility volatility) {
+set_Load_volatility (ir_node *node, ir_volatility volatility) {
   assert(node->op == op_Load);
   node->attr.load.volatility = volatility;
 }
@@ -1732,14 +1745,14 @@ set_Store_value (ir_node *node, ir_node *value) {
   set_irn_n(node, 2, value);
 }
 
-ent_volatility
+ir_volatility
 get_Store_volatility (ir_node *node) {
   assert(node->op == op_Store);
   return node->attr.store.volatility;
 }
 
 void
-set_Store_volatility (ir_node *node, ent_volatility volatility) {
+set_Store_volatility (ir_node *node, ir_volatility volatility) {
   assert(node->op == op_Store);
   node->attr.store.volatility = volatility;
 }
@@ -2363,10 +2376,10 @@ get_irn_irg(const ir_node *node) {
 ir_node *
 skip_Proj (ir_node *node) {
   /* don't assert node !!! */
-  if (node && is_Proj(node)) {
+  if (node != NULL && is_Proj(node)) {
     return get_Proj_pred(node);
   } else {
-    return node;
+    return (ir_node*) node;
   }
 }
 
@@ -2512,6 +2525,36 @@ int
   return _is_Bad(node);
 }
 
+int
+(is_NoMem)(const ir_node *node) {
+       return _is_NoMem(node);
+}
+
+int
+(is_Mod)(const ir_node *node) {
+       return _is_Mod(node);
+}
+
+int
+(is_Div)(const ir_node *node) {
+       return _is_Div(node);
+}
+
+int
+(is_DivMod)(const ir_node *node) {
+       return _is_DivMod(node);
+}
+
+int
+(is_Start)(const ir_node *node) {
+  return _is_Start(node);
+}
+
+int
+(is_End)(const ir_node *node) {
+       return _is_End(node);
+}
+
 int
 (is_Const)(const ir_node *node) {
        return _is_Const(node);
@@ -2575,6 +2618,12 @@ int
   return _is_Confirm(node);
 }
 
+/* returns true if node is a Pin node. */
+int
+(is_Pin)(const ir_node *node) {
+  return _is_Pin(node);
+}
+
 /* returns true if node is a SymConst node. */
 int
 (is_SymConst)(const ir_node *node) {
@@ -2599,6 +2648,18 @@ int
   return _is_Alloc(node);
 }
 
+/* returns true if a node is a Jmp node. */
+int
+(is_Jmp)(const ir_node *node) {
+  return _is_Jmp(node);
+}
+
+/* returns true if a node is a Raise node. */
+int
+(is_Raise)(const ir_node *node) {
+  return _is_Raise(node);
+}
+
 int
 is_Proj (const ir_node *node) {
   assert(node);
@@ -2638,6 +2699,7 @@ ir_node *get_fragile_op_mem(ir_node *node) {
   case iro_Load  :
   case iro_Store :
   case iro_Alloc :
+  case iro_Bound :
     return get_irn_n(node, 0);
   case iro_Bad   :
   case iro_Unknown:
@@ -2684,6 +2746,13 @@ int (is_irn_keep)(const ir_node *node) {
   return _is_irn_keep(node);
 }
 
+/*
+ * Returns non-zero for nodes that are always placed in the start block.
+ */
+int (is_irn_start_block_placed)(const ir_node *node) {
+  return _is_irn_start_block_placed(node);
+}
+
 /* Returns non-zero for nodes that are machine operations. */
 int (is_irn_machine_op)(const ir_node *node) {
        return _is_irn_machine_op(node);