Don't check nunber of Proj's for dead blocks
[libfirm] / ir / ir / irnode.c
index 58a50e4..7828fca 100644 (file)
@@ -162,6 +162,9 @@ new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mo
     int not_a_block = is_no_Block(res);
 
     INIT_LIST_HEAD(&res->edge_info.outs_head);
+    if(!not_a_block)
+      INIT_LIST_HEAD(&res->attr.block.succ_head);
+
 
     for (i = 0, n = arity + not_a_block; i < n; ++i)
       edges_notify_edge(res, i - not_a_block, res->in[i], NULL, irg);
@@ -407,6 +410,11 @@ op_pin_state
   return _get_irn_pinned(node);
 }
 
+op_pin_state
+(is_irn_pinned_in_irg) (const ir_node *node) {
+  return _is_irn_pinned_in_irg(node);
+}
+
 void set_irn_pinned(ir_node *node, op_pin_state state) {
   /* due to optimization an opt may be turned into a Tuple */
   if (get_irn_op(node) == op_Tuple)
@@ -539,12 +547,18 @@ get_irn_except_attr (ir_node *node)
   return node->attr.except;
 }
 
+void *
+get_irn_generic_attr (ir_node *node) {
+  return &node->attr;
+}
+
 /** manipulate fields of individual nodes **/
 
 /* this works for all except Block */
 ir_node *
 get_nodes_block (const ir_node *node) {
   assert (!(node->op == op_Block));
+       assert (is_irn_pinned_in_irg(node) && "block info may be incorrect");
   return get_irn_n(node, -1);
 }
 
@@ -617,6 +631,11 @@ set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
   set_irn_n(node, pos, pred);
 }
 
+ir_node  *
+(get_Block_cfgpred_block)(ir_node *node, int pos) {
+  return _get_Block_cfgpred_block(node, pos);
+}
+
 bool
 get_Block_matured (ir_node *node) {
   assert (node->op == op_Block);
@@ -765,6 +784,17 @@ free_End (ir_node *end) {
                in array afterwards ... */
 }
 
+/* Return the target address of an IJmp */
+ir_node *get_IJmp_target(ir_node *ijmp) {
+  assert(ijmp->op == op_IJmp);
+  return get_irn_n(ijmp, 0);
+}
+
+/** Sets the target address of an IJmp */
+void set_IJmp_target(ir_node *ijmp, ir_node *tgt) {
+  assert(ijmp->op == op_IJmp);
+  set_irn_n(ijmp, 0, tgt);
+}
 
 /*
 > Implementing the case construct (which is where the constant Proj node is
@@ -1992,13 +2022,18 @@ void     set_Mux_true  (ir_node *node, ir_node *ir_true) {
   node->in[3] = ir_true;
 }
 
-
 ir_graph *
 get_irn_irg(const ir_node *node) {
+       /*
+        * Do not use get_nodes_Block() here, because this
+        * will check the pinned state.
+        * However even a 'wrong' block is always in the proper
+        * irg.
+        */
   if (! is_Block(node))
-    node = get_nodes_block(node);
+    node = get_irn_n(node, -1);
   if (is_Bad(node))  /* sometimes bad is predecessor of nodes instead of block: in case of optimization */
-    node = get_nodes_block(node);
+    node = get_irn_n(node, -1);
   assert(get_irn_op(node) == op_Block);
   return node->attr.block.irg;
 }
@@ -2021,16 +2056,33 @@ skip_Proj (ir_node *node) {
 ir_node *
 skip_Tuple (ir_node *node) {
   ir_node *pred;
+  ir_op   *op;
 
   if (!get_opt_normalize()) return node;
 
+restart:
   node = skip_Id(node);
   if (get_irn_op(node) == op_Proj) {
     pred = skip_Id(get_Proj_pred(node));
-    if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
+    op   = get_irn_op(pred);
+
+    /*
+     * Looks strange but calls get_irn_op() only once
+     * in most often cases.
+     */
+    if (op == op_Proj) { /* nested Tuple ? */
       pred = skip_Id(skip_Tuple(pred));
-    else if (get_irn_op(pred) == op_Tuple)
-      return get_Tuple_pred(pred, get_Proj_proj(node));
+      op   = get_irn_op(pred);
+
+      if (op == op_Tuple) {
+        node = get_Tuple_pred(pred, get_Proj_proj(node));
+        goto restart;
+      }
+    }
+    else if (op == op_Tuple) {
+      node = get_Tuple_pred(pred, get_Proj_proj(node));
+      goto restart;
+    }
   }
   return node;
 }
@@ -2199,15 +2251,40 @@ ir_node *get_fragile_op_mem(ir_node *node) {
 }
 
 /* Returns true if the operation is a forking control flow operation. */
-int
-is_forking_op(const ir_node *node) {
-  return is_op_forking(get_irn_op(node));
+int (is_irn_forking)(const ir_node *node) {
+  return _is_irn_forking(node);
 }
 
 type *(get_irn_type)(ir_node *node) {
   return _get_irn_type(node);
 }
 
+/* Returns non-zero for constant-like nodes. */
+int (is_irn_constlike)(const ir_node *node) {
+  return _is_irn_constlike(node);
+}
+
+/* Gets the string representation of the jump prediction .*/
+const char *get_cond_jmp_predicate_name(cond_jmp_predicate pred)
+{
+  switch (pred) {
+  default:
+  case COND_JMP_PRED_NONE:  return "no prediction";
+  case COND_JMP_PRED_TRUE:  return "true taken";
+  case COND_JMP_PRED_FALSE: return "false taken";
+  }
+}
+
+/* Returns the conditional jump prediction of a Cond node. */
+cond_jmp_predicate (get_Cond_jmp_pred)(ir_node *cond) {
+  return _get_Cond_jmp_pred(cond);
+}
+
+/* Sets a new conditional jump prediction. */
+void (set_Cond_jmp_pred)(ir_node *cond, cond_jmp_predicate pred) {
+  _set_Cond_jmp_pred(cond, pred);
+}
+
 /** the get_type operation must be always implemented */
 static type *get_Null_type(ir_node *n) {
   return NULL;