Fixed optimization of Div/Mod/DivMod nodes

[libfirm] / ir / ir / irnode.c

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index e3b5fa3..e7b77be 100644 (file)
--- a/ir/ir/irnode.c
+++ b/ir/ir/irnode.c
@@ -56,27 +56,14 @@ const char *get_pnc_string(int pnc) {
 /*
  * Calculates the negated (Complement(R)) pnc condition.
  */
-int
-get_negated_pnc(int pnc) {
-  switch (pnc) {
-  case pn_Cmp_False: return pn_Cmp_True;
-  case pn_Cmp_Eq:    return pn_Cmp_Ne;
-  case pn_Cmp_Lt:    return pn_Cmp_Uge;
-  case pn_Cmp_Le:    return pn_Cmp_Ug;
-  case pn_Cmp_Gt:    return pn_Cmp_Ule;
-  case pn_Cmp_Ge:    return pn_Cmp_Ul;
-  case pn_Cmp_Lg:    return pn_Cmp_Ue;
-  case pn_Cmp_Leg:   return pn_Cmp_Uo;
-  case pn_Cmp_Uo:    return pn_Cmp_Leg;
-  case pn_Cmp_Ue:    return pn_Cmp_Lg;
-  case pn_Cmp_Ul:    return pn_Cmp_Ge;
-  case pn_Cmp_Ule:   return pn_Cmp_Gt;
-  case pn_Cmp_Ug:    return pn_Cmp_Le;
-  case pn_Cmp_Uge:   return pn_Cmp_Lt;
-  case pn_Cmp_Ne:    return pn_Cmp_Eq;
-  case pn_Cmp_True:  return pn_Cmp_False;
-  }
-  return 99; /* to shut up gcc */
+int get_negated_pnc(int pnc, ir_mode *mode) {
+  pnc ^= pn_Cmp_True;
+
+  /* do NOT add the Uo bit for non-floating point values */
+  if (! mode_is_float(mode))
+    pnc &= ~pn_Cmp_Uo;
+
+  return pnc;
 }
 
 /* Calculates the inversed (R^-1) pnc condition, i.e., "<" --> ">" */
@@ -175,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);
@@ -420,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)
@@ -558,6 +553,7 @@ get_irn_except_attr (ir_node *node)
 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);
 }
 
@@ -615,16 +611,13 @@ get_Block_cfgpred_arr (ir_node *node)
 }
 
 int
-get_Block_n_cfgpreds (ir_node *node) {
-  assert ((node->op == op_Block));
-  return get_irn_arity(node);
+(get_Block_n_cfgpreds)(ir_node *node) {
+  return get_Block_n_cfgpreds(node);
 }
 
 ir_node *
-get_Block_cfgpred (ir_node *node, int pos) {
-  assert(-1 <= pos && pos < get_irn_arity(node));
-  assert(node->op == op_Block);
-  return get_irn_n(node, pos);
+(get_Block_cfgpred)(ir_node *node, int pos) {
+  return get_Block_cfgpred(node, pos);
 }
 
 void
@@ -633,6 +626,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);
@@ -781,6 +779,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
@@ -2008,13 +2017,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;
 }