OSDN Git Service

2006-02-15 Paolo Bonzini <bonzini@gnu.org>
[pf3gnuchains/gcc-fork.git] / gcc / ifcvt.c
index 782960b..5d156a6 100644 (file)
@@ -1,5 +1,6 @@
 /* If-conversion support.
 /* If-conversion support.
-   Copyright (C) 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
+   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005
+   Free Software Foundation, Inc.
 
    This file is part of GCC.
 
 
    This file is part of GCC.
 
@@ -15,8 +16,8 @@
 
    You should have received a copy of the GNU General Public License
    along with GCC; see the file COPYING.  If not, write to the Free
 
    You should have received a copy of the GNU General Public License
    along with GCC; see the file COPYING.  If not, write to the Free
-   Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-   02111-1307, USA.  */
+   Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+   02110-1301, USA.  */
 
 #include "config.h"
 #include "system.h"
 
 #include "config.h"
 #include "system.h"
@@ -40,6 +41,8 @@
 #include "tm_p.h"
 #include "cfgloop.h"
 #include "target.h"
 #include "tm_p.h"
 #include "cfgloop.h"
 #include "target.h"
+#include "timevar.h"
+#include "tree-pass.h"
 
 
 #ifndef HAVE_conditional_execution
 
 
 #ifndef HAVE_conditional_execution
@@ -65,8 +68,7 @@
 #define MAX_CONDITIONAL_EXECUTE   (BRANCH_COST + 1)
 #endif
 
 #define MAX_CONDITIONAL_EXECUTE   (BRANCH_COST + 1)
 #endif
 
-#define NULL_EDGE      ((struct edge_def *)NULL)
-#define NULL_BLOCK     ((struct basic_block_def *)NULL)
+#define NULL_BLOCK     ((basic_block) NULL)
 
 /* # of IF-THEN or IF-THEN-ELSE blocks we looked at  */
 static int num_possible_if_blocks;
 
 /* # of IF-THEN or IF-THEN-ELSE blocks we looked at  */
 static int num_possible_if_blocks;
@@ -75,8 +77,8 @@ static int num_possible_if_blocks;
    execution.  */
 static int num_updated_if_blocks;
 
    execution.  */
 static int num_updated_if_blocks;
 
-/* # of basic blocks that were removed.  */
-static int num_removed_blocks;
+/* # of changes made which require life information to be updated.  */
+static int num_true_changes;
 
 /* Whether conditional execution changes were made.  */
 static int cond_exec_changed_p;
 
 /* Whether conditional execution changes were made.  */
 static int cond_exec_changed_p;
@@ -84,14 +86,11 @@ static int cond_exec_changed_p;
 /* True if life data ok at present.  */
 static bool life_data_ok;
 
 /* True if life data ok at present.  */
 static bool life_data_ok;
 
-/* The post-dominator relation on the original block numbers.  */
-static dominance_info post_dominators;
-
 /* Forward references.  */
 static int count_bb_insns (basic_block);
 /* Forward references.  */
 static int count_bb_insns (basic_block);
+static bool cheap_bb_rtx_cost_p (basic_block, int);
 static rtx first_active_insn (basic_block);
 static rtx last_active_insn (basic_block, int);
 static rtx first_active_insn (basic_block);
 static rtx last_active_insn (basic_block, int);
-static int seq_contains_jump (rtx);
 static basic_block block_fallthru (basic_block);
 static int cond_exec_process_insns (ce_if_block_t *, rtx, rtx, rtx, rtx, int);
 static rtx cond_exec_get_condition (rtx);
 static basic_block block_fallthru (basic_block);
 static int cond_exec_process_insns (ce_if_block_t *, rtx, rtx, rtx, rtx, int);
 static rtx cond_exec_get_condition (rtx);
@@ -112,55 +111,72 @@ static int dead_or_predicable (basic_block, basic_block, basic_block,
                               basic_block, int);
 static void noce_emit_move_insn (rtx, rtx);
 static rtx block_has_only_trap (basic_block);
                               basic_block, int);
 static void noce_emit_move_insn (rtx, rtx);
 static rtx block_has_only_trap (basic_block);
-static void mark_loop_exit_edges (void);
 \f
 \f
-/* Sets EDGE_LOOP_EXIT flag for all loop exits.  */
-static void
-mark_loop_exit_edges ()
+/* Count the number of non-jump active insns in BB.  */
+
+static int
+count_bb_insns (basic_block bb)
 {
 {
-  struct loops loops;
-  basic_block bb;
-  edge e;
-  
-  flow_loops_find (&loops, LOOP_TREE);
-  
-  if (loops.num > 1)
+  int count = 0;
+  rtx insn = BB_HEAD (bb);
+
+  while (1)
     {
     {
-      FOR_EACH_BB (bb)
-       {
-         for (e = bb->succ; e; e = e->succ_next)
-           {
-             if (find_common_loop (bb->loop_father, e->dest->loop_father)
-                 != bb->loop_father)
-               e->flags |= EDGE_LOOP_EXIT;
-             else
-               e->flags &= ~EDGE_LOOP_EXIT;
-           }
-       }
+      if (CALL_P (insn) || NONJUMP_INSN_P (insn))
+       count++;
+
+      if (insn == BB_END (bb))
+       break;
+      insn = NEXT_INSN (insn);
     }
 
     }
 
-  flow_loops_free (&loops);
+  return count;
 }
 
 }
 
-/* Count the number of non-jump active insns in BB.  */
+/* Determine whether the total insn_rtx_cost on non-jump insns in
+   basic block BB is less than MAX_COST.  This function returns
+   false if the cost of any instruction could not be estimated.  */
 
 
-static int
-count_bb_insns (basic_block bb)
+static bool
+cheap_bb_rtx_cost_p (basic_block bb, int max_cost)
 {
   int count = 0;
 {
   int count = 0;
-  rtx insn = bb->head;
+  rtx insn = BB_HEAD (bb);
 
   while (1)
     {
 
   while (1)
     {
-      if (GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == INSN)
-       count++;
+      if (NONJUMP_INSN_P (insn))
+       {
+         int cost = insn_rtx_cost (PATTERN (insn));
+         if (cost == 0)
+           return false;
+
+         /* If this instruction is the load or set of a "stack" register,
+            such as a floating point register on x87, then the cost of
+            speculatively executing this instruction needs to include
+            the additional cost of popping this register off of the
+            register stack.  */
+#ifdef STACK_REGS
+         {
+           rtx set = single_set (insn);
+           if (set && STACK_REG_P (SET_DEST (set)))
+             cost += COSTS_N_INSNS (1);
+         }
+#endif
 
 
-      if (insn == bb->end)
+         count += cost;
+         if (count >= max_cost)
+           return false;
+       }
+      else if (CALL_P (insn))
+       return false;
+      if (insn == BB_END (bb))
        break;
       insn = NEXT_INSN (insn);
     }
 
        break;
       insn = NEXT_INSN (insn);
     }
 
-  return count;
+  return true;
 }
 
 /* Return the first non-jump active insn in the basic block.  */
 }
 
 /* Return the first non-jump active insn in the basic block.  */
@@ -168,23 +184,23 @@ count_bb_insns (basic_block bb)
 static rtx
 first_active_insn (basic_block bb)
 {
 static rtx
 first_active_insn (basic_block bb)
 {
-  rtx insn = bb->head;
+  rtx insn = BB_HEAD (bb);
 
 
-  if (GET_CODE (insn) == CODE_LABEL)
+  if (LABEL_P (insn))
     {
     {
-      if (insn == bb->end)
+      if (insn == BB_END (bb))
        return NULL_RTX;
       insn = NEXT_INSN (insn);
     }
 
        return NULL_RTX;
       insn = NEXT_INSN (insn);
     }
 
-  while (GET_CODE (insn) == NOTE)
+  while (NOTE_P (insn))
     {
     {
-      if (insn == bb->end)
+      if (insn == BB_END (bb))
        return NULL_RTX;
       insn = NEXT_INSN (insn);
     }
 
        return NULL_RTX;
       insn = NEXT_INSN (insn);
     }
 
-  if (GET_CODE (insn) == JUMP_INSN)
+  if (JUMP_P (insn))
     return NULL_RTX;
 
   return insn;
     return NULL_RTX;
 
   return insn;
@@ -195,13 +211,13 @@ first_active_insn (basic_block bb)
 static rtx
 last_active_insn (basic_block bb, int skip_use_p)
 {
 static rtx
 last_active_insn (basic_block bb, int skip_use_p)
 {
-  rtx insn = bb->end;
-  rtx head = bb->head;
+  rtx insn = BB_END (bb);
+  rtx head = BB_HEAD (bb);
 
 
-  while (GET_CODE (insn) == NOTE
-        || GET_CODE (insn) == JUMP_INSN
+  while (NOTE_P (insn)
+        || JUMP_P (insn)
         || (skip_use_p
         || (skip_use_p
-            && GET_CODE (insn) == INSN
+            && NONJUMP_INSN_P (insn)
             && GET_CODE (PATTERN (insn)) == USE))
     {
       if (insn == head)
             && GET_CODE (PATTERN (insn)) == USE))
     {
       if (insn == head)
@@ -209,38 +225,23 @@ last_active_insn (basic_block bb, int skip_use_p)
       insn = PREV_INSN (insn);
     }
 
       insn = PREV_INSN (insn);
     }
 
-  if (GET_CODE (insn) == CODE_LABEL)
+  if (LABEL_P (insn))
     return NULL_RTX;
 
   return insn;
 }
 
     return NULL_RTX;
 
   return insn;
 }
 
-/* It is possible, especially when having dealt with multi-word
-   arithmetic, for the expanders to have emitted jumps.  Search
-   through the sequence and return TRUE if a jump exists so that
-   we can abort the conversion.  */
-
-static int
-seq_contains_jump (rtx insn)
-{
-  while (insn)
-    {
-      if (GET_CODE (insn) == JUMP_INSN)
-       return 1;
-      insn = NEXT_INSN (insn);
-    }
-  return 0;
-}
+/* Return the basic block reached by falling though the basic block BB.  */
 
 static basic_block
 block_fallthru (basic_block bb)
 {
   edge e;
 
 static basic_block
 block_fallthru (basic_block bb)
 {
   edge e;
+  edge_iterator ei;
 
 
-  for (e = bb->succ;
-       e != NULL_EDGE && (e->flags & EDGE_FALLTHRU) == 0;
-       e = e->succ_next)
-    ;
+  FOR_EACH_EDGE (e, ei, bb->succs)
+    if (e->flags & EDGE_FALLTHRU)
+      break;
 
   return (e) ? e->dest : NULL_BLOCK;
 }
 
   return (e) ? e->dest : NULL_BLOCK;
 }
@@ -267,20 +268,17 @@ cond_exec_process_insns (ce_if_block_t *ce_info ATTRIBUTE_UNUSED,
 
   for (insn = start; ; insn = NEXT_INSN (insn))
     {
 
   for (insn = start; ; insn = NEXT_INSN (insn))
     {
-      if (GET_CODE (insn) == NOTE)
+      if (NOTE_P (insn))
        goto insn_done;
 
        goto insn_done;
 
-      if (GET_CODE (insn) != INSN && GET_CODE (insn) != CALL_INSN)
-       abort ();
+      gcc_assert(NONJUMP_INSN_P (insn) || CALL_P (insn));
 
       /* Remove USE insns that get in the way.  */
       if (reload_completed && GET_CODE (PATTERN (insn)) == USE)
        {
          /* ??? Ug.  Actually unlinking the thing is problematic,
             given what we'd have to coordinate with our callers.  */
 
       /* Remove USE insns that get in the way.  */
       if (reload_completed && GET_CODE (PATTERN (insn)) == USE)
        {
          /* ??? Ug.  Actually unlinking the thing is problematic,
             given what we'd have to coordinate with our callers.  */
-         PUT_CODE (insn, NOTE);
-         NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
-         NOTE_SOURCE_FILE (insn) = 0;
+         SET_INSN_DELETED (insn);
          goto insn_done;
        }
 
          goto insn_done;
        }
 
@@ -324,7 +322,7 @@ cond_exec_process_insns (ce_if_block_t *ce_info ATTRIBUTE_UNUSED,
 
       validate_change (insn, &PATTERN (insn), pattern, 1);
 
 
       validate_change (insn, &PATTERN (insn), pattern, 1);
 
-      if (GET_CODE (insn) == CALL_INSN && prob_val)
+      if (CALL_P (insn) && prob_val)
        validate_change (insn, &REG_NOTES (insn),
                         alloc_EXPR_LIST (REG_BR_PROB, prob_val,
                                          REG_NOTES (insn)), 1);
        validate_change (insn, &REG_NOTES (insn),
                         alloc_EXPR_LIST (REG_BR_PROB, prob_val,
                                          REG_NOTES (insn)), 1);
@@ -407,13 +405,13 @@ cond_exec_process_if_block (ce_if_block_t * ce_info,
 
   /* Find the conditional jump to the ELSE or JOIN part, and isolate
      the test.  */
 
   /* Find the conditional jump to the ELSE or JOIN part, and isolate
      the test.  */
-  test_expr = cond_exec_get_condition (test_bb->end);
+  test_expr = cond_exec_get_condition (BB_END (test_bb));
   if (! test_expr)
     return FALSE;
 
   /* If the conditional jump is more than just a conditional jump,
      then we can not do conditional execution conversion on this block.  */
   if (! test_expr)
     return FALSE;
 
   /* If the conditional jump is more than just a conditional jump,
      then we can not do conditional execution conversion on this block.  */
-  if (! onlyjump_p (test_bb->end))
+  if (! onlyjump_p (BB_END (test_bb)))
     return FALSE;
 
   /* Collect the bounds of where we're to search, skipping any labels, jumps
     return FALSE;
 
   /* Collect the bounds of where we're to search, skipping any labels, jumps
@@ -440,7 +438,7 @@ cond_exec_process_if_block (ce_if_block_t * ce_info,
 
   true_expr = test_expr;
 
 
   true_expr = test_expr;
 
-  false_code = reversed_comparison_code (true_expr, test_bb->end);
+  false_code = reversed_comparison_code (true_expr, BB_END (test_bb));
   if (false_code != UNKNOWN)
     false_expr = gen_rtx_fmt_ee (false_code, GET_MODE (true_expr),
                                 XEXP (true_expr, 0), XEXP (true_expr, 1));
   if (false_code != UNKNOWN)
     false_expr = gen_rtx_fmt_ee (false_code, GET_MODE (true_expr),
                                 XEXP (true_expr, 0), XEXP (true_expr, 1));
@@ -452,12 +450,12 @@ cond_exec_process_if_block (ce_if_block_t * ce_info,
      conditional execution register from a comparison, it can do so here.  */
   IFCVT_MODIFY_TESTS (ce_info, true_expr, false_expr);
 
      conditional execution register from a comparison, it can do so here.  */
   IFCVT_MODIFY_TESTS (ce_info, true_expr, false_expr);
 
-  /* See if the conversion failed */
+  /* See if the conversion failed */
   if (!true_expr || !false_expr)
     goto fail;
 #endif
 
   if (!true_expr || !false_expr)
     goto fail;
 #endif
 
-  true_prob_val = find_reg_note (test_bb->end, REG_BR_PROB, NULL_RTX);
+  true_prob_val = find_reg_note (BB_END (test_bb), REG_BR_PROB, NULL_RTX);
   if (true_prob_val)
     {
       true_prob_val = XEXP (true_prob_val, 0);
   if (true_prob_val)
     {
       true_prob_val = XEXP (true_prob_val, 0);
@@ -480,6 +478,7 @@ cond_exec_process_if_block (ce_if_block_t * ce_info,
        {
          rtx start, end;
          rtx t, f;
        {
          rtx start, end;
          rtx t, f;
+         enum rtx_code f_code;
 
          bb = block_fallthru (bb);
          start = first_active_insn (bb);
 
          bb = block_fallthru (bb);
          start = first_active_insn (bb);
@@ -491,19 +490,19 @@ cond_exec_process_if_block (ce_if_block_t * ce_info,
 
          /* If the conditional jump is more than just a conditional jump, then
             we can not do conditional execution conversion on this block.  */
 
          /* If the conditional jump is more than just a conditional jump, then
             we can not do conditional execution conversion on this block.  */
-         if (! onlyjump_p (bb->end))
+         if (! onlyjump_p (BB_END (bb)))
            goto fail;
 
          /* Find the conditional jump and isolate the test.  */
            goto fail;
 
          /* Find the conditional jump and isolate the test.  */
-         t = cond_exec_get_condition (bb->end);
+         t = cond_exec_get_condition (BB_END (bb));
          if (! t)
            goto fail;
 
          if (! t)
            goto fail;
 
-         f = gen_rtx_fmt_ee (reverse_condition (GET_CODE (t)),
-                             GET_MODE (t),
-                             XEXP (t, 0),
-                             XEXP (t, 1));
+         f_code = reversed_comparison_code (t, BB_END (bb));
+         if (f_code == UNKNOWN)
+           goto fail;
 
 
+         f = gen_rtx_fmt_ee (f_code, GET_MODE (t), XEXP (t, 0), XEXP (t, 1));
          if (ce_info->and_and_p)
            {
              t = gen_rtx_AND (GET_MODE (t), true_expr, t);
          if (ce_info->and_and_p)
            {
              t = gen_rtx_AND (GET_MODE (t), true_expr, t);
@@ -521,7 +520,7 @@ cond_exec_process_if_block (ce_if_block_t * ce_info,
 #ifdef IFCVT_MODIFY_MULTIPLE_TESTS
          IFCVT_MODIFY_MULTIPLE_TESTS (ce_info, bb, t, f);
 
 #ifdef IFCVT_MODIFY_MULTIPLE_TESTS
          IFCVT_MODIFY_MULTIPLE_TESTS (ce_info, bb, t, f);
 
-         /* See if the conversion failed */
+         /* See if the conversion failed */
          if (!t || !f)
            goto fail;
 #endif
          if (!t || !f)
            goto fail;
 #endif
@@ -563,13 +562,13 @@ cond_exec_process_if_block (ce_if_block_t * ce_info,
     }
 
 #ifdef IFCVT_MODIFY_FINAL
     }
 
 #ifdef IFCVT_MODIFY_FINAL
-  /* Do any machine dependent final modifications */
+  /* Do any machine dependent final modifications */
   IFCVT_MODIFY_FINAL (ce_info);
 #endif
 
   /* Conversion succeeded.  */
   IFCVT_MODIFY_FINAL (ce_info);
 #endif
 
   /* Conversion succeeded.  */
-  if (rtl_dump_file)
-    fprintf (rtl_dump_file, "%d insn%s converted to conditional execution.\n",
+  if (dump_file)
+    fprintf (dump_file, "%d insn%s converted to conditional execution.\n",
             n_insns, (n_insns == 1) ? " was" : "s were");
 
   /* Merge the blocks!  */
             n_insns, (n_insns == 1) ? " was" : "s were");
 
   /* Merge the blocks!  */
@@ -599,9 +598,12 @@ struct noce_if_info
   rtx insn_a, insn_b;
   rtx x, a, b;
   rtx jump, cond, cond_earliest;
   rtx insn_a, insn_b;
   rtx x, a, b;
   rtx jump, cond, cond_earliest;
+  /* True if "b" was originally evaluated unconditionally.  */
+  bool b_unconditional;
 };
 
 static rtx noce_emit_store_flag (struct noce_if_info *, rtx, int, int);
 };
 
 static rtx noce_emit_store_flag (struct noce_if_info *, rtx, int, int);
+static int noce_try_move (struct noce_if_info *);
 static int noce_try_store_flag (struct noce_if_info *);
 static int noce_try_addcc (struct noce_if_info *);
 static int noce_try_store_flag_constants (struct noce_if_info *);
 static int noce_try_store_flag (struct noce_if_info *);
 static int noce_try_addcc (struct noce_if_info *);
 static int noce_try_store_flag_constants (struct noce_if_info *);
@@ -613,6 +615,7 @@ static int noce_try_cmove_arith (struct noce_if_info *);
 static rtx noce_get_alt_condition (struct noce_if_info *, rtx, rtx *);
 static int noce_try_minmax (struct noce_if_info *);
 static int noce_try_abs (struct noce_if_info *);
 static rtx noce_get_alt_condition (struct noce_if_info *, rtx, rtx *);
 static int noce_try_minmax (struct noce_if_info *);
 static int noce_try_abs (struct noce_if_info *);
+static int noce_try_sign_mask (struct noce_if_info *);
 
 /* Helper function for noce_try_store_flag*.  */
 
 
 /* Helper function for noce_try_store_flag*.  */
 
@@ -674,27 +677,154 @@ noce_emit_store_flag (struct noce_if_info *if_info, rtx x, int reversep,
                           || code == GEU || code == GTU), normalize);
 }
 
                           || code == GEU || code == GTU), normalize);
 }
 
-/* Emit instruction to move an rtx into STRICT_LOW_PART.  */
+/* Emit instruction to move an rtx, possibly into STRICT_LOW_PART.
+   X is the destination/target and Y is the value to copy.  */
+
 static void
 noce_emit_move_insn (rtx x, rtx y)
 {
 static void
 noce_emit_move_insn (rtx x, rtx y)
 {
-  enum machine_mode outmode, inmode;
+  enum machine_mode outmode;
   rtx outer, inner;
   int bitpos;
 
   if (GET_CODE (x) != STRICT_LOW_PART)
     {
   rtx outer, inner;
   int bitpos;
 
   if (GET_CODE (x) != STRICT_LOW_PART)
     {
-      emit_move_insn (x, y);
+      rtx seq, insn, target;
+      optab ot;
+
+      start_sequence ();
+      /* Check that the SET_SRC is reasonable before calling emit_move_insn,
+        otherwise construct a suitable SET pattern ourselves.  */
+      insn = (OBJECT_P (y) || CONSTANT_P (y) || GET_CODE (y) == SUBREG)
+            ? emit_move_insn (x, y)
+            : emit_insn (gen_rtx_SET (VOIDmode, x, y));
+      seq = get_insns ();
+      end_sequence();
+
+      if (recog_memoized (insn) <= 0)
+       switch (GET_RTX_CLASS (GET_CODE (y)))
+         {
+         case RTX_UNARY:
+           ot = code_to_optab[GET_CODE (y)];
+           if (ot)
+             {
+               start_sequence ();
+               target = expand_unop (GET_MODE (y), ot, XEXP (y, 0), x, 0);
+               if (target != NULL_RTX)
+                 {
+                   if (target != x)
+                     emit_move_insn (x, target);
+                   seq = get_insns ();
+                 }
+               end_sequence ();
+             }
+           break;
+
+         case RTX_BIN_ARITH:
+         case RTX_COMM_ARITH:
+           ot = code_to_optab[GET_CODE (y)];
+           if (ot)
+             {
+               start_sequence ();
+               target = expand_binop (GET_MODE (y), ot,
+                                      XEXP (y, 0), XEXP (y, 1),
+                                      x, 0, OPTAB_DIRECT);
+               if (target != NULL_RTX)
+                 {
+                   if (target != x)
+                     emit_move_insn (x, target);
+                   seq = get_insns ();
+                 }
+               end_sequence ();
+             }
+           break;
+
+         default:
+           break;
+         }
+
+      emit_insn (seq);
       return;
     }
 
   outer = XEXP (x, 0);
   inner = XEXP (outer, 0);
   outmode = GET_MODE (outer);
       return;
     }
 
   outer = XEXP (x, 0);
   inner = XEXP (outer, 0);
   outmode = GET_MODE (outer);
-  inmode = GET_MODE (inner);
   bitpos = SUBREG_BYTE (outer) * BITS_PER_UNIT;
   bitpos = SUBREG_BYTE (outer) * BITS_PER_UNIT;
-  store_bit_field (inner, GET_MODE_BITSIZE (outmode), bitpos, outmode, y,
-                  GET_MODE_BITSIZE (inmode));
+  store_bit_field (inner, GET_MODE_BITSIZE (outmode), bitpos, outmode, y);
+}
+
+/* Return sequence of instructions generated by if conversion.  This
+   function calls end_sequence() to end the current stream, ensures
+   that are instructions are unshared, recognizable non-jump insns.
+   On failure, this function returns a NULL_RTX.  */
+
+static rtx
+end_ifcvt_sequence (struct noce_if_info *if_info)
+{
+  rtx insn;
+  rtx seq = get_insns ();
+
+  set_used_flags (if_info->x);
+  set_used_flags (if_info->cond);
+  unshare_all_rtl_in_chain (seq);
+  end_sequence ();
+
+  /* Make sure that all of the instructions emitted are recognizable,
+     and that we haven't introduced a new jump instruction.
+     As an exercise for the reader, build a general mechanism that
+     allows proper placement of required clobbers.  */
+  for (insn = seq; insn; insn = NEXT_INSN (insn))
+    if (JUMP_P (insn)
+       || recog_memoized (insn) == -1)
+      return NULL_RTX;
+
+  return seq;
+}
+
+/* Convert "if (a != b) x = a; else x = b" into "x = a" and
+   "if (a == b) x = a; else x = b" into "x = b".  */
+
+static int
+noce_try_move (struct noce_if_info *if_info)
+{
+  rtx cond = if_info->cond;
+  enum rtx_code code = GET_CODE (cond);
+  rtx y, seq;
+
+  if (code != NE && code != EQ)
+    return FALSE;
+
+  /* This optimization isn't valid if either A or B could be a NaN
+     or a signed zero.  */
+  if (HONOR_NANS (GET_MODE (if_info->x))
+      || HONOR_SIGNED_ZEROS (GET_MODE (if_info->x)))
+    return FALSE;
+
+  /* Check whether the operands of the comparison are A and in
+     either order.  */
+  if ((rtx_equal_p (if_info->a, XEXP (cond, 0))
+       && rtx_equal_p (if_info->b, XEXP (cond, 1)))
+      || (rtx_equal_p (if_info->a, XEXP (cond, 1))
+         && rtx_equal_p (if_info->b, XEXP (cond, 0))))
+    {
+      y = (code == EQ) ? if_info->a : if_info->b;
+
+      /* Avoid generating the move if the source is the destination.  */
+      if (! rtx_equal_p (if_info->x, y))
+       {
+         start_sequence ();
+         noce_emit_move_insn (if_info->x, y);
+         seq = end_ifcvt_sequence (if_info);
+         if (!seq)
+           return FALSE;
+
+         emit_insn_before_setloc (seq, if_info->jump,
+                                  INSN_LOCATOR (if_info->insn_a));
+       }
+      return TRUE;
+    }
+  return FALSE;
 }
 
 /* Convert "if (test) x = 1; else x = 0".
 }
 
 /* Convert "if (test) x = 1; else x = 0".
@@ -730,10 +860,12 @@ noce_try_store_flag (struct noce_if_info *if_info)
       if (target != if_info->x)
        noce_emit_move_insn (if_info->x, target);
 
       if (target != if_info->x)
        noce_emit_move_insn (if_info->x, target);
 
-      seq = get_insns ();
-      end_sequence ();
-      emit_insn_before_setloc (seq, if_info->jump, INSN_LOCATOR (if_info->insn_a));
+      seq = end_ifcvt_sequence (if_info);
+      if (! seq)
+       return FALSE;
 
 
+      emit_insn_before_setloc (seq, if_info->jump,
+                              INSN_LOCATOR (if_info->insn_a));
       return TRUE;
     }
   else
       return TRUE;
     }
   else
@@ -860,14 +992,12 @@ noce_try_store_flag_constants (struct noce_if_info *if_info)
       if (target != if_info->x)
        noce_emit_move_insn (if_info->x, target);
 
       if (target != if_info->x)
        noce_emit_move_insn (if_info->x, target);
 
-      seq = get_insns ();
-      end_sequence ();
-
-      if (seq_contains_jump (seq))
+      seq = end_ifcvt_sequence (if_info);
+      if (!seq)
        return FALSE;
 
        return FALSE;
 
-      emit_insn_before_setloc (seq, if_info->jump, INSN_LOCATOR (if_info->insn_a));
-
+      emit_insn_before_setloc (seq, if_info->jump,
+                              INSN_LOCATOR (if_info->insn_a));
       return TRUE;
     }
 
       return TRUE;
     }
 
@@ -884,10 +1014,8 @@ noce_try_addcc (struct noce_if_info *if_info)
   int subtract, normalize;
 
   if (! no_new_pseudos
   int subtract, normalize;
 
   if (! no_new_pseudos
-      /* Should be no `else' case to worry about.  */
-      && if_info->b == if_info->x
       && GET_CODE (if_info->a) == PLUS
       && GET_CODE (if_info->a) == PLUS
-      && rtx_equal_p (XEXP (if_info->a, 0), if_info->x)
+      && rtx_equal_p (XEXP (if_info->a, 0), if_info->b)
       && (reversed_comparison_code (if_info->cond, if_info->jump)
          != UNKNOWN))
     {
       && (reversed_comparison_code (if_info->cond, if_info->jump)
          != UNKNOWN))
     {
@@ -900,9 +1028,11 @@ noce_try_addcc (struct noce_if_info *if_info)
        {
          start_sequence ();
          target = emit_conditional_add (if_info->x, code,
        {
          start_sequence ();
          target = emit_conditional_add (if_info->x, code,
-                                        XEXP (cond, 0), XEXP (cond, 1),
+                                        XEXP (cond, 0),
+                                        XEXP (cond, 1),
                                         VOIDmode,
                                         VOIDmode,
-                                        if_info->b, XEXP (if_info->a, 1),
+                                        if_info->b,
+                                        XEXP (if_info->a, 1),
                                         GET_MODE (if_info->x),
                                         (code == LTU || code == GEU
                                          || code == LEU || code == GTU));
                                         GET_MODE (if_info->x),
                                         (code == LTU || code == GEU
                                          || code == LEU || code == GTU));
@@ -911,10 +1041,12 @@ noce_try_addcc (struct noce_if_info *if_info)
              if (target != if_info->x)
                noce_emit_move_insn (if_info->x, target);
 
              if (target != if_info->x)
                noce_emit_move_insn (if_info->x, target);
 
-             seq = get_insns ();
-             end_sequence ();
+             seq = end_ifcvt_sequence (if_info);
+             if (!seq)
+               return FALSE;
+
              emit_insn_before_setloc (seq, if_info->jump,
              emit_insn_before_setloc (seq, if_info->jump,
-                                     INSN_LOCATOR (if_info->insn_a));
+                                      INSN_LOCATOR (if_info->insn_a));
              return TRUE;
            }
          end_sequence ();
              return TRUE;
            }
          end_sequence ();
@@ -942,22 +1074,19 @@ noce_try_addcc (struct noce_if_info *if_info)
          if (target)
            target = expand_simple_binop (GET_MODE (if_info->x),
                                          subtract ? MINUS : PLUS,
          if (target)
            target = expand_simple_binop (GET_MODE (if_info->x),
                                          subtract ? MINUS : PLUS,
-                                         if_info->x, target, if_info->x,
+                                         if_info->b, target, if_info->x,
                                          0, OPTAB_WIDEN);
          if (target)
            {
              if (target != if_info->x)
                noce_emit_move_insn (if_info->x, target);
 
                                          0, OPTAB_WIDEN);
          if (target)
            {
              if (target != if_info->x)
                noce_emit_move_insn (if_info->x, target);
 
-             seq = get_insns ();
-             end_sequence ();
-
-             if (seq_contains_jump (seq))
+             seq = end_ifcvt_sequence (if_info);
+             if (!seq)
                return FALSE;
 
              emit_insn_before_setloc (seq, if_info->jump,
                return FALSE;
 
              emit_insn_before_setloc (seq, if_info->jump,
-                                     INSN_LOCATOR (if_info->insn_a));
-
+                                      INSN_LOCATOR (if_info->insn_a));
              return TRUE;
            }
          end_sequence ();
              return TRUE;
            }
          end_sequence ();
@@ -993,7 +1122,8 @@ noce_try_store_flag_mask (struct noce_if_info *if_info)
                                     reversep, -1);
       if (target)
         target = expand_simple_binop (GET_MODE (if_info->x), AND,
                                     reversep, -1);
       if (target)
         target = expand_simple_binop (GET_MODE (if_info->x), AND,
-                                     if_info->x, target, if_info->x, 0,
+                                     if_info->x,
+                                     target, if_info->x, 0,
                                      OPTAB_WIDEN);
 
       if (target)
                                      OPTAB_WIDEN);
 
       if (target)
@@ -1001,15 +1131,12 @@ noce_try_store_flag_mask (struct noce_if_info *if_info)
          if (target != if_info->x)
            noce_emit_move_insn (if_info->x, target);
 
          if (target != if_info->x)
            noce_emit_move_insn (if_info->x, target);
 
-         seq = get_insns ();
-         end_sequence ();
-
-         if (seq_contains_jump (seq))
+         seq = end_ifcvt_sequence (if_info);
+         if (!seq)
            return FALSE;
 
          emit_insn_before_setloc (seq, if_info->jump,
            return FALSE;
 
          emit_insn_before_setloc (seq, if_info->jump,
-                                 INSN_LOCATOR (if_info->insn_a));
-
+                                  INSN_LOCATOR (if_info->insn_a));
          return TRUE;
        }
 
          return TRUE;
        }
 
@@ -1098,10 +1225,12 @@ noce_try_cmove (struct noce_if_info *if_info)
          if (target != if_info->x)
            noce_emit_move_insn (if_info->x, target);
 
          if (target != if_info->x)
            noce_emit_move_insn (if_info->x, target);
 
-         seq = get_insns ();
-         end_sequence ();
+         seq = end_ifcvt_sequence (if_info);
+         if (!seq)
+           return FALSE;
+
          emit_insn_before_setloc (seq, if_info->jump,
          emit_insn_before_setloc (seq, if_info->jump,
-                                 INSN_LOCATOR (if_info->insn_a));
+                                  INSN_LOCATOR (if_info->insn_a));
          return TRUE;
        }
       else
          return TRUE;
        }
       else
@@ -1122,9 +1251,11 @@ noce_try_cmove_arith (struct noce_if_info *if_info)
   rtx a = if_info->a;
   rtx b = if_info->b;
   rtx x = if_info->x;
   rtx a = if_info->a;
   rtx b = if_info->b;
   rtx x = if_info->x;
+  rtx orig_a, orig_b;
   rtx insn_a, insn_b;
   rtx tmp, target;
   int is_mem = 0;
   rtx insn_a, insn_b;
   rtx tmp, target;
   int is_mem = 0;
+  int insn_cost;
   enum rtx_code code;
 
   /* A conditional move from two memory sources is equivalent to a
   enum rtx_code code;
 
   /* A conditional move from two memory sources is equivalent to a
@@ -1132,7 +1263,7 @@ noce_try_cmove_arith (struct noce_if_info *if_info)
      early because it'll screw alias analysis.  Note that we've
      already checked for no side effects.  */
   if (! no_new_pseudos && cse_not_expected
      early because it'll screw alias analysis.  Note that we've
      already checked for no side effects.  */
   if (! no_new_pseudos && cse_not_expected
-      && GET_CODE (a) == MEM && GET_CODE (b) == MEM
+      && MEM_P (a) && MEM_P (b)
       && BRANCH_COST >= 5)
     {
       a = XEXP (a, 0);
       && BRANCH_COST >= 5)
     {
       a = XEXP (a, 0);
@@ -1158,6 +1289,25 @@ noce_try_cmove_arith (struct noce_if_info *if_info)
   insn_a = if_info->insn_a;
   insn_b = if_info->insn_b;
 
   insn_a = if_info->insn_a;
   insn_b = if_info->insn_b;
 
+  /* Total insn_rtx_cost should be smaller than branch cost.  Exit
+     if insn_rtx_cost can't be estimated.  */
+  if (insn_a)
+    {
+      insn_cost = insn_rtx_cost (PATTERN (insn_a));
+      if (insn_cost == 0 || insn_cost > COSTS_N_INSNS (BRANCH_COST))
+       return FALSE;
+    }
+  else
+    {
+      insn_cost = 0;
+    }
+
+  if (insn_b) {
+    insn_cost += insn_rtx_cost (PATTERN (insn_b));
+    if (insn_cost == 0 || insn_cost > COSTS_N_INSNS (BRANCH_COST))
+      return FALSE;
+  }
+
   /* Possibly rearrange operands to make things come out more natural.  */
   if (reversed_comparison_code (if_info->cond, if_info->jump) != UNKNOWN)
     {
   /* Possibly rearrange operands to make things come out more natural.  */
   if (reversed_comparison_code (if_info->cond, if_info->jump) != UNKNOWN)
     {
@@ -1177,6 +1327,9 @@ noce_try_cmove_arith (struct noce_if_info *if_info)
 
   start_sequence ();
 
 
   start_sequence ();
 
+  orig_a = a;
+  orig_b = b;
+
   /* If either operand is complex, load it into a register first.
      The best way to do this is to copy the original insn.  In this
      way we preserve any clobbers etc that the insn may have had.
   /* If either operand is complex, load it into a register first.
      The best way to do this is to copy the original insn.  In this
      way we preserve any clobbers etc that the insn may have had.
@@ -1208,7 +1361,7 @@ noce_try_cmove_arith (struct noce_if_info *if_info)
     }
   if (! general_operand (b, GET_MODE (b)))
     {
     }
   if (! general_operand (b, GET_MODE (b)))
     {
-      rtx set;
+      rtx set, last;
 
       if (no_new_pseudos)
        goto end_seq_and_fail;
 
       if (no_new_pseudos)
        goto end_seq_and_fail;
@@ -1216,7 +1369,7 @@ noce_try_cmove_arith (struct noce_if_info *if_info)
       if (is_mem)
        {
           tmp = gen_reg_rtx (GET_MODE (b));
       if (is_mem)
        {
           tmp = gen_reg_rtx (GET_MODE (b));
-         tmp = emit_insn (gen_rtx_SET (VOIDmode, tmp, b));
+         tmp = gen_rtx_SET (VOIDmode, tmp, b);
        }
       else if (! insn_b)
        goto end_seq_and_fail;
        }
       else if (! insn_b)
        goto end_seq_and_fail;
@@ -1226,8 +1379,22 @@ noce_try_cmove_arith (struct noce_if_info *if_info)
          tmp = copy_rtx (insn_b);
          set = single_set (tmp);
          SET_DEST (set) = b;
          tmp = copy_rtx (insn_b);
          set = single_set (tmp);
          SET_DEST (set) = b;
-         tmp = emit_insn (PATTERN (tmp));
+         tmp = PATTERN (tmp);
+       }
+
+      /* If insn to set up A clobbers any registers B depends on, try to
+        swap insn that sets up A with the one that sets up B.  If even
+        that doesn't help, punt.  */
+      last = get_last_insn ();
+      if (last && modified_in_p (orig_b, last))
+       {
+         tmp = emit_insn_before (tmp, get_insns ());
+         if (modified_in_p (orig_a, tmp))
+           goto end_seq_and_fail;
        }
        }
+      else
+       tmp = emit_insn (tmp);
+
       if (recog_memoized (tmp) < 0)
        goto end_seq_and_fail;
     }
       if (recog_memoized (tmp) < 0)
        goto end_seq_and_fail;
     }
@@ -1260,8 +1427,10 @@ noce_try_cmove_arith (struct noce_if_info *if_info)
   else if (target != x)
     noce_emit_move_insn (x, target);
 
   else if (target != x)
     noce_emit_move_insn (x, target);
 
-  tmp = get_insns ();
-  end_sequence ();
+  tmp = end_ifcvt_sequence (if_info);
+  if (!tmp)
+    return FALSE;
+
   emit_insn_before_setloc (tmp, if_info->jump, INSN_LOCATOR (if_info->insn_a));
   return TRUE;
 
   emit_insn_before_setloc (tmp, if_info->jump, INSN_LOCATOR (if_info->insn_a));
   return TRUE;
 
@@ -1316,7 +1485,7 @@ noce_get_alt_condition (struct noce_if_info *if_info, rtx target,
       rtx prev_insn;
 
       /* First, look to see if we put a constant in a register.  */
       rtx prev_insn;
 
       /* First, look to see if we put a constant in a register.  */
-      prev_insn = PREV_INSN (if_info->cond_earliest);
+      prev_insn = prev_nonnote_insn (if_info->cond_earliest);
       if (prev_insn
          && INSN_P (prev_insn)
          && GET_CODE (PATTERN (prev_insn)) == SET)
       if (prev_insn
          && INSN_P (prev_insn)
          && GET_CODE (PATTERN (prev_insn)) == SET)
@@ -1397,7 +1566,7 @@ noce_get_alt_condition (struct noce_if_info *if_info, rtx target,
     }
 
   cond = canonicalize_condition (if_info->jump, cond, reverse,
     }
 
   cond = canonicalize_condition (if_info->jump, cond, reverse,
-                                earliest, target, false);
+                                earliest, target, false, true);
   if (! cond || ! reg_mentioned_p (target, cond))
     return NULL;
 
   if (! cond || ! reg_mentioned_p (target, cond))
     return NULL;
 
@@ -1505,10 +1674,8 @@ noce_try_minmax (struct noce_if_info *if_info)
   if (target != if_info->x)
     noce_emit_move_insn (if_info->x, target);
 
   if (target != if_info->x)
     noce_emit_move_insn (if_info->x, target);
 
-  seq = get_insns ();
-  end_sequence ();
-
-  if (seq_contains_jump (seq))
+  seq = end_ifcvt_sequence (if_info);
+  if (!seq)
     return FALSE;
 
   emit_insn_before_setloc (seq, if_info->jump, INSN_LOCATOR (if_info->insn_a));
     return FALSE;
 
   emit_insn_before_setloc (seq, if_info->jump, INSN_LOCATOR (if_info->insn_a));
@@ -1530,7 +1697,9 @@ noce_try_abs (struct noce_if_info *if_info)
   if (no_new_pseudos)
     return FALSE;
 
   if (no_new_pseudos)
     return FALSE;
 
-  /* Recognize A and B as constituting an ABS or NABS.  */
+  /* Recognize A and B as constituting an ABS or NABS.  The canonical
+     form is a branch around the negation, taken when the object is the
+     first operand of a comparison against 0 that evaluates to true.  */
   a = if_info->a;
   b = if_info->b;
   if (GET_CODE (a) == NEG && rtx_equal_p (XEXP (a, 0), b))
   a = if_info->a;
   b = if_info->b;
   if (GET_CODE (a) == NEG && rtx_equal_p (XEXP (a, 0), b))
@@ -1551,27 +1720,32 @@ noce_try_abs (struct noce_if_info *if_info)
   if (rtx_equal_p (XEXP (cond, 0), b))
     c = XEXP (cond, 1);
   else if (rtx_equal_p (XEXP (cond, 1), b))
   if (rtx_equal_p (XEXP (cond, 0), b))
     c = XEXP (cond, 1);
   else if (rtx_equal_p (XEXP (cond, 1), b))
-    c = XEXP (cond, 0);
+    {
+      c = XEXP (cond, 0);
+      negate = !negate;
+    }
   else
     return FALSE;
 
   else
     return FALSE;
 
-  /* Verify that C is zero.  Search backward through the block for
-     a REG_EQUAL note if necessary.  */
+  /* Verify that C is zero.  Search one step backward for a
+     REG_EQUAL note or a simple source if necessary.  */
   if (REG_P (c))
     {
   if (REG_P (c))
     {
-      rtx insn, note = NULL;
-      for (insn = earliest;
-          insn != if_info->test_bb->head;
-          insn = PREV_INSN (insn))
-       if (INSN_P (insn)
-           && ((note = find_reg_note (insn, REG_EQUAL, c))
-               || (note = find_reg_note (insn, REG_EQUIV, c))))
-         break;
-      if (! note)
+      rtx set, insn = prev_nonnote_insn (earliest);
+      if (insn
+         && (set = single_set (insn))
+         && rtx_equal_p (SET_DEST (set), c))
+       {
+         rtx note = find_reg_equal_equiv_note (insn);
+         if (note)
+           c = XEXP (note, 0);
+         else
+           c = SET_SRC (set);
+       }
+      else
        return FALSE;
        return FALSE;
-      c = XEXP (note, 0);
     }
     }
-  if (GET_CODE (c) == MEM
+  if (MEM_P (c)
       && GET_CODE (XEXP (c, 0)) == SYMBOL_REF
       && CONSTANT_POOL_ADDRESS_P (XEXP (c, 0)))
     c = get_pool_constant (XEXP (c, 0));
       && GET_CODE (XEXP (c, 0)) == SYMBOL_REF
       && CONSTANT_POOL_ADDRESS_P (XEXP (c, 0)))
     c = get_pool_constant (XEXP (c, 0));
@@ -1608,7 +1782,7 @@ noce_try_abs (struct noce_if_info *if_info)
 
   target = expand_abs_nojump (GET_MODE (if_info->x), b, if_info->x, 1);
 
 
   target = expand_abs_nojump (GET_MODE (if_info->x), b, if_info->x, 1);
 
-  /* ??? It's a quandry whether cmove would be better here, especially
+  /* ??? It's a quandary whether cmove would be better here, especially
      for integers.  Perhaps combine will clean things up.  */
   if (target && negate)
     target = expand_simple_unop (GET_MODE (target), NEG, target, if_info->x, 0);
      for integers.  Perhaps combine will clean things up.  */
   if (target && negate)
     target = expand_simple_unop (GET_MODE (target), NEG, target, if_info->x, 0);
@@ -1622,10 +1796,8 @@ noce_try_abs (struct noce_if_info *if_info)
   if (target != if_info->x)
     noce_emit_move_insn (if_info->x, target);
 
   if (target != if_info->x)
     noce_emit_move_insn (if_info->x, target);
 
-  seq = get_insns ();
-  end_sequence ();
-
-  if (seq_contains_jump (seq))
+  seq = end_ifcvt_sequence (if_info);
+  if (!seq)
     return FALSE;
 
   emit_insn_before_setloc (seq, if_info->jump, INSN_LOCATOR (if_info->insn_a));
     return FALSE;
 
   emit_insn_before_setloc (seq, if_info->jump, INSN_LOCATOR (if_info->insn_a));
@@ -1635,13 +1807,183 @@ noce_try_abs (struct noce_if_info *if_info)
   return TRUE;
 }
 
   return TRUE;
 }
 
+/* Convert "if (m < 0) x = b; else x = 0;" to "x = (m >> C) & b;".  */
+
+static int
+noce_try_sign_mask (struct noce_if_info *if_info)
+{
+  rtx cond, t, m, c, seq;
+  enum machine_mode mode;
+  enum rtx_code code;
+
+  if (no_new_pseudos)
+    return FALSE;
+
+  cond = if_info->cond;
+  code = GET_CODE (cond);
+  m = XEXP (cond, 0);
+  c = XEXP (cond, 1);
+
+  t = NULL_RTX;
+  if (if_info->a == const0_rtx)
+    {
+      if ((code == LT && c == const0_rtx)
+         || (code == LE && c == constm1_rtx))
+       t = if_info->b;
+    }
+  else if (if_info->b == const0_rtx)
+    {
+      if ((code == GE && c == const0_rtx)
+         || (code == GT && c == constm1_rtx))
+       t = if_info->a;
+    }
+
+  if (! t || side_effects_p (t))
+    return FALSE;
+
+  /* We currently don't handle different modes.  */
+  mode = GET_MODE (t);
+  if (GET_MODE (m) != mode)
+    return FALSE;
+
+  /* This is only profitable if T is cheap, or T is unconditionally
+     executed/evaluated in the original insn sequence.  */
+  if (rtx_cost (t, SET) >= COSTS_N_INSNS (2)
+      && (!if_info->b_unconditional
+          || t != if_info->b))
+    return FALSE;
+
+  start_sequence ();
+  /* Use emit_store_flag to generate "m < 0 ? -1 : 0" instead of expanding
+     "(signed) m >> 31" directly.  This benefits targets with specialized
+     insns to obtain the signmask, but still uses ashr_optab otherwise.  */
+  m = emit_store_flag (gen_reg_rtx (mode), LT, m, const0_rtx, mode, 0, -1);
+  t = m ? expand_binop (mode, and_optab, m, t, NULL_RTX, 0, OPTAB_DIRECT)
+       : NULL_RTX;
+
+  if (!t)
+    {
+      end_sequence ();
+      return FALSE;
+    }
+
+  noce_emit_move_insn (if_info->x, t);
+
+  seq = end_ifcvt_sequence (if_info);
+  if (!seq)
+    return FALSE;
+
+  emit_insn_before_setloc (seq, if_info->jump, INSN_LOCATOR (if_info->insn_a));
+  return TRUE;
+}
+
+
+/* Optimize away "if (x & C) x |= C" and similar bit manipulation
+   transformations.  */
+
+static int
+noce_try_bitop (struct noce_if_info *if_info)
+{
+  rtx cond, x, a, result, seq;
+  enum machine_mode mode;
+  enum rtx_code code;
+  int bitnum;
+
+  x = if_info->x;
+  cond = if_info->cond;
+  code = GET_CODE (cond);
+
+  /* Check for no else condition.  */
+  if (! rtx_equal_p (x, if_info->b))
+    return FALSE;
+
+  /* Check for a suitable condition.  */
+  if (code != NE && code != EQ)
+    return FALSE;
+  if (XEXP (cond, 1) != const0_rtx)
+    return FALSE;
+  cond = XEXP (cond, 0);
+
+  /* ??? We could also handle AND here.  */
+  if (GET_CODE (cond) == ZERO_EXTRACT)
+    {
+      if (XEXP (cond, 1) != const1_rtx
+         || GET_CODE (XEXP (cond, 2)) != CONST_INT
+         || ! rtx_equal_p (x, XEXP (cond, 0)))
+       return FALSE;
+      bitnum = INTVAL (XEXP (cond, 2));
+      mode = GET_MODE (x);
+      if (bitnum >= HOST_BITS_PER_WIDE_INT)
+       return FALSE;
+    }
+  else
+    return FALSE;
+
+  a = if_info->a;
+  if (GET_CODE (a) == IOR || GET_CODE (a) == XOR)
+    {
+      /* Check for "if (X & C) x = x op C".  */
+      if (! rtx_equal_p (x, XEXP (a, 0))
+          || GET_CODE (XEXP (a, 1)) != CONST_INT
+         || (INTVAL (XEXP (a, 1)) & GET_MODE_MASK (mode))
+            != (unsigned HOST_WIDE_INT) 1 << bitnum)
+        return FALSE;
+
+      /* if ((x & C) == 0) x |= C; is transformed to x |= C.   */
+      /* if ((x & C) != 0) x |= C; is transformed to nothing.  */
+      if (GET_CODE (a) == IOR)
+       result = (code == NE) ? a : NULL_RTX;
+      else if (code == NE)
+       {
+         /* if ((x & C) == 0) x ^= C; is transformed to x |= C.   */
+         result = gen_int_mode ((HOST_WIDE_INT) 1 << bitnum, mode);
+         result = simplify_gen_binary (IOR, mode, x, result);
+       }
+      else
+       {
+         /* if ((x & C) != 0) x ^= C; is transformed to x &= ~C.  */
+         result = gen_int_mode (~((HOST_WIDE_INT) 1 << bitnum), mode);
+         result = simplify_gen_binary (AND, mode, x, result);
+       }
+    }
+  else if (GET_CODE (a) == AND)
+    {
+      /* Check for "if (X & C) x &= ~C".  */
+      if (! rtx_equal_p (x, XEXP (a, 0))
+         || GET_CODE (XEXP (a, 1)) != CONST_INT
+         || (INTVAL (XEXP (a, 1)) & GET_MODE_MASK (mode))
+            != (~((HOST_WIDE_INT) 1 << bitnum) & GET_MODE_MASK (mode)))
+        return FALSE;
+
+      /* if ((x & C) == 0) x &= ~C; is transformed to nothing.  */
+      /* if ((x & C) != 0) x &= ~C; is transformed to x &= ~C.  */
+      result = (code == EQ) ? a : NULL_RTX;
+    }
+  else
+    return FALSE;
+
+  if (result)
+    {
+      start_sequence ();
+      noce_emit_move_insn (x, result);
+      seq = end_ifcvt_sequence (if_info);
+      if (!seq)
+       return FALSE;
+
+      emit_insn_before_setloc (seq, if_info->jump,
+                              INSN_LOCATOR (if_info->insn_a));
+    }
+  return TRUE;
+}
+
+
 /* Similar to get_condition, only the resulting condition must be
    valid at JUMP, instead of at EARLIEST.  */
 
 static rtx
 noce_get_condition (rtx jump, rtx *earliest)
 {
 /* Similar to get_condition, only the resulting condition must be
    valid at JUMP, instead of at EARLIEST.  */
 
 static rtx
 noce_get_condition (rtx jump, rtx *earliest)
 {
-  rtx cond, set, tmp, insn;
+  rtx cond, set, tmp;
   bool reverse;
 
   if (! any_condjump_p (jump))
   bool reverse;
 
   if (! any_condjump_p (jump))
@@ -1670,38 +2012,54 @@ noce_get_condition (rtx jump, rtx *earliest)
 
   /* Otherwise, fall back on canonicalize_condition to do the dirty
      work of manipulating MODE_CC values and COMPARE rtx codes.  */
 
   /* Otherwise, fall back on canonicalize_condition to do the dirty
      work of manipulating MODE_CC values and COMPARE rtx codes.  */
+  return canonicalize_condition (jump, cond, reverse, earliest,
+                                NULL_RTX, false, true);
+}
 
 
-  tmp = canonicalize_condition (jump, cond, reverse, earliest, NULL_RTX,
-                               false);
-  if (!tmp)
-    return NULL_RTX;
+/* Initialize for a simple IF-THEN or IF-THEN-ELSE block.  We will not
+   be using conditional execution.  Set some fields of IF_INFO based
+   on CE_INFO: test_bb, cond, jump, cond_earliest.  Return TRUE if
+   things look OK.  */
 
 
-  /* We are going to insert code before JUMP, not before EARLIEST.
-     We must therefore be certain that the given condition is valid
-     at JUMP by virtue of not having been modified since.  */
-  for (insn = *earliest; insn != jump; insn = NEXT_INSN (insn))
-    if (INSN_P (insn) && modified_in_p (tmp, insn))
-      break;
-  if (insn == jump)
-    return tmp;
-
-  /* The condition was modified.  See if we can get a partial result
-     that doesn't follow all the reversals.  Perhaps combine can fold
-     them together later.  */
-  tmp = XEXP (tmp, 0);
-  if (!REG_P (tmp) || GET_MODE_CLASS (GET_MODE (tmp)) != MODE_INT)
-    return NULL_RTX;
-  tmp = canonicalize_condition (jump, cond, reverse, earliest, tmp,
-                               false);
-  if (!tmp)
-    return NULL_RTX;
+static int
+noce_init_if_info (struct ce_if_block *ce_info, struct noce_if_info *if_info)
+{
+  basic_block test_bb = ce_info->test_bb;
+  rtx cond, jump;
 
 
-  /* For sanity's sake, re-validate the new result.  */
-  for (insn = *earliest; insn != jump; insn = NEXT_INSN (insn))
-    if (INSN_P (insn) && modified_in_p (tmp, insn))
-      return NULL_RTX;
+  /* If test is comprised of && or || elements, don't handle it unless
+     it is the special case of && elements without an ELSE block.  */
+  if (ce_info->num_multiple_test_blocks)
+    {
+      if (ce_info->else_bb || !ce_info->and_and_p)
+       return FALSE;
+
+      ce_info->test_bb = test_bb = ce_info->last_test_bb;
+      ce_info->num_multiple_test_blocks = 0;
+      ce_info->num_and_and_blocks = 0;
+      ce_info->num_or_or_blocks = 0;
+    }
 
 
-  return tmp;
+  /* If this is not a standard conditional jump, we can't parse it.  */
+  jump = BB_END (test_bb);
+  cond = noce_get_condition (jump, &if_info->cond_earliest);
+  if (!cond)
+    return FALSE;
+
+  /* If the conditional jump is more than just a conditional
+     jump, then we can not do if-conversion on this block.  */
+  if (! onlyjump_p (jump))
+    return FALSE;
+
+  /* We must be comparing objects whose modes imply the size.  */
+  if (GET_MODE (XEXP (cond, 0)) == BLKmode)
+    return FALSE;
+
+  if_info->test_bb = test_bb;
+  if_info->cond = cond;
+  if_info->jump = jump;
+
+  return TRUE;
 }
 
 /* Return true if OP is ok for if-then-else processing.  */
 }
 
 /* Return true if OP is ok for if-then-else processing.  */
@@ -1711,7 +2069,7 @@ noce_operand_ok (rtx op)
 {
   /* We special-case memories, so handle any of them with
      no address side effects.  */
 {
   /* We special-case memories, so handle any of them with
      no address side effects.  */
-  if (GET_CODE (op) == MEM)
+  if (MEM_P (op))
     return ! side_effects_p (XEXP (op, 0));
 
   if (side_effects_p (op))
     return ! side_effects_p (XEXP (op, 0));
 
   if (side_effects_p (op))
@@ -1720,6 +2078,59 @@ noce_operand_ok (rtx op)
   return ! may_trap_p (op);
 }
 
   return ! may_trap_p (op);
 }
 
+/* Return true if a write into MEM may trap or fault.  */
+
+static bool
+noce_mem_write_may_trap_or_fault_p (rtx mem)
+{
+  rtx addr;
+
+  if (MEM_READONLY_P (mem))
+    return true;
+
+  if (may_trap_or_fault_p (mem))
+    return true;
+
+  addr = XEXP (mem, 0);
+
+  /* Call target hook to avoid the effects of -fpic etc....  */
+  addr = targetm.delegitimize_address (addr);
+
+  while (addr)
+    switch (GET_CODE (addr))
+      {
+      case CONST:
+      case PRE_DEC:
+      case PRE_INC:
+      case POST_DEC:
+      case POST_INC:
+      case POST_MODIFY:
+       addr = XEXP (addr, 0);
+       break;
+      case LO_SUM:
+      case PRE_MODIFY:
+       addr = XEXP (addr, 1);
+       break;
+      case PLUS:
+       if (GET_CODE (XEXP (addr, 1)) == CONST_INT)
+         addr = XEXP (addr, 0);
+       else
+         return false;
+       break;
+      case LABEL_REF:
+       return true;
+      case SYMBOL_REF:
+       if (SYMBOL_REF_DECL (addr)
+           && decl_readonly_section (SYMBOL_REF_DECL (addr), 0))
+         return true;
+       return false;
+      default:
+       return false;
+      }
+
+  return false;
+}
+
 /* Given a simple IF-THEN or IF-THEN-ELSE block, attempt to convert it
    without using conditional execution.  Return TRUE if we were
    successful at converting the block.  */
 /* Given a simple IF-THEN or IF-THEN-ELSE block, attempt to convert it
    without using conditional execution.  Return TRUE if we were
    successful at converting the block.  */
@@ -1746,33 +2157,11 @@ noce_process_if_block (struct ce_if_block * ce_info)
 
      ??? For future expansion, look for multiple X in such patterns.  */
 
 
      ??? For future expansion, look for multiple X in such patterns.  */
 
-  /* If test is comprised of && or || elements, don't handle it unless it is
-     the special case of && elements without an ELSE block.  */
-  if (ce_info->num_multiple_test_blocks)
-    {
-      if (else_bb || ! ce_info->and_and_p)
-       return FALSE;
-
-      ce_info->test_bb = test_bb = ce_info->last_test_bb;
-      ce_info->num_multiple_test_blocks = 0;
-      ce_info->num_and_and_blocks = 0;
-      ce_info->num_or_or_blocks = 0;
-    }
-
-  /* If this is not a standard conditional jump, we can't parse it.  */
-  jump = test_bb->end;
-  cond = noce_get_condition (jump, &if_info.cond_earliest);
-  if (! cond)
+  if (!noce_init_if_info (ce_info, &if_info))
     return FALSE;
 
     return FALSE;
 
-  /* If the conditional jump is more than just a conditional
-     jump, then we can not do if-conversion on this block.  */
-  if (! onlyjump_p (jump))
-    return FALSE;
-
-  /* We must be comparing objects whose modes imply the size.  */
-  if (GET_MODE (XEXP (cond, 0)) == BLKmode)
-    return FALSE;
+  cond = if_info.cond;
+  jump = if_info.jump;
 
   /* Look for one of the potential sets.  */
   insn_a = first_active_insn (then_bb);
 
   /* Look for one of the potential sets.  */
   insn_a = first_active_insn (then_bb);
@@ -1808,7 +2197,7 @@ noce_process_if_block (struct ce_if_block * ce_info)
         COND_EARLIEST to JUMP.  Make sure the relevant data is still
         intact.  */
       if (! insn_b
         COND_EARLIEST to JUMP.  Make sure the relevant data is still
         intact.  */
       if (! insn_b
-         || GET_CODE (insn_b) != INSN
+         || !NONJUMP_INSN_P (insn_b)
          || (set_b = single_set (insn_b)) == NULL_RTX
          || ! rtx_equal_p (x, SET_DEST (set_b))
          || reg_overlap_mentioned_p (x, SET_SRC (set_b))
          || (set_b = single_set (insn_b)) == NULL_RTX
          || ! rtx_equal_p (x, SET_DEST (set_b))
          || reg_overlap_mentioned_p (x, SET_SRC (set_b))
@@ -1836,7 +2225,7 @@ noce_process_if_block (struct ce_if_block * ce_info)
   /* Only operate on register destinations, and even then avoid extending
      the lifetime of hard registers on small register class machines.  */
   orig_x = x;
   /* Only operate on register destinations, and even then avoid extending
      the lifetime of hard registers on small register class machines.  */
   orig_x = x;
-  if (GET_CODE (x) != REG
+  if (!REG_P (x)
       || (SMALL_REGISTER_CLASSES
          && REGNO (x) < FIRST_PSEUDO_REGISTER))
     {
       || (SMALL_REGISTER_CLASSES
          && REGNO (x) < FIRST_PSEUDO_REGISTER))
     {
@@ -1851,14 +2240,12 @@ noce_process_if_block (struct ce_if_block * ce_info)
     return FALSE;
 
   /* Set up the info block for our subroutines.  */
     return FALSE;
 
   /* Set up the info block for our subroutines.  */
-  if_info.test_bb = test_bb;
-  if_info.cond = cond;
-  if_info.jump = jump;
   if_info.insn_a = insn_a;
   if_info.insn_b = insn_b;
   if_info.x = x;
   if_info.a = a;
   if_info.b = b;
   if_info.insn_a = insn_a;
   if_info.insn_b = insn_b;
   if_info.x = x;
   if_info.a = a;
   if_info.b = b;
+  if_info.b_unconditional = else_bb == 0;
 
   /* Try optimizations in some approximation of a useful order.  */
   /* ??? Should first look to see if X is live incoming at all.  If it
 
   /* Try optimizations in some approximation of a useful order.  */
   /* ??? Should first look to see if X is live incoming at all.  If it
@@ -1876,8 +2263,8 @@ noce_process_if_block (struct ce_if_block * ce_info)
        {
          rtx note;
 
        {
          rtx note;
 
-         if (else_bb && insn_b == else_bb->end)
-           else_bb->end = PREV_INSN (insn_b);
+         if (else_bb && insn_b == BB_END (else_bb))
+           BB_END (else_bb) = PREV_INSN (insn_b);
          reorder_insns (insn_b, insn_b, PREV_INSN (jump));
 
          /* If there was a REG_EQUAL note, delete it since it may have been
          reorder_insns (insn_b, insn_b, PREV_INSN (jump));
 
          /* If there was a REG_EQUAL note, delete it since it may have been
@@ -1896,8 +2283,24 @@ noce_process_if_block (struct ce_if_block * ce_info)
       goto success;
     }
 
       goto success;
     }
 
+  /* Disallow the "if (...) x = a;" form (with an implicit "else x = x;")
+     for optimizations if writing to x may trap or fault, i.e. it's a memory
+     other than a static var or a stack slot, is misaligned on strict
+     aligned machines or is read-only.
+     If x is a read-only memory, then the program is valid only if we
+     avoid the store into it.  If there are stores on both the THEN and
+     ELSE arms, then we can go ahead with the conversion; either the
+     program is broken, or the condition is always false such that the
+     other memory is selected.  */
+  if (!set_b && MEM_P (orig_x) && noce_mem_write_may_trap_or_fault_p (orig_x))
+    return FALSE;
+
+  if (noce_try_move (&if_info))
+    goto success;
   if (noce_try_store_flag (&if_info))
     goto success;
   if (noce_try_store_flag (&if_info))
     goto success;
+  if (noce_try_bitop (&if_info))
+    goto success;
   if (noce_try_minmax (&if_info))
     goto success;
   if (noce_try_abs (&if_info))
   if (noce_try_minmax (&if_info))
     goto success;
   if (noce_try_abs (&if_info))
@@ -1916,6 +2319,8 @@ noce_process_if_block (struct ce_if_block * ce_info)
       if (HAVE_conditional_move
          && noce_try_cmove_arith (&if_info))
        goto success;
       if (HAVE_conditional_move
          && noce_try_cmove_arith (&if_info))
        goto success;
+      if (noce_try_sign_mask (&if_info))
+       goto success;
     }
 
   return FALSE;
     }
 
   return FALSE;
@@ -1942,11 +2347,13 @@ noce_process_if_block (struct ce_if_block * ce_info)
   if (orig_x != x)
     {
       start_sequence ();
   if (orig_x != x)
     {
       start_sequence ();
-      noce_emit_move_insn (copy_rtx (orig_x), x);
+      noce_emit_move_insn (orig_x, x);
       insn_b = get_insns ();
       insn_b = get_insns ();
+      set_used_flags (orig_x);
+      unshare_all_rtl_in_chain (insn_b);
       end_sequence ();
 
       end_sequence ();
 
-      emit_insn_after_setloc (insn_b, test_bb->end, INSN_LOCATOR (insn_a));
+      emit_insn_after_setloc (insn_b, BB_END (test_bb), INSN_LOCATOR (insn_a));
     }
 
   /* Merge the blocks!  */
     }
 
   /* Merge the blocks!  */
@@ -1954,6 +2361,235 @@ noce_process_if_block (struct ce_if_block * ce_info)
 
   return TRUE;
 }
 
   return TRUE;
 }
+
+/* Check whether a block is suitable for conditional move conversion.
+   Every insn must be a simple set of a register to a constant or a
+   register.  For each assignment, store the value in the array VALS,
+   indexed by register number.  COND is the condition we will
+   test.  */
+
+static int
+check_cond_move_block (basic_block bb, rtx *vals, rtx cond)
+{
+  rtx insn;
+
+  FOR_BB_INSNS (bb, insn)
+    {
+      rtx set, dest, src;
+
+      if (!INSN_P (insn) || JUMP_P (insn))
+       continue;
+      set = single_set (insn);
+      if (!set)
+       return FALSE;
+
+      dest = SET_DEST (set);
+      src = SET_SRC (set);
+      if (!REG_P (dest)
+         || (SMALL_REGISTER_CLASSES && HARD_REGISTER_P (dest)))
+       return false;
+
+      if (!CONSTANT_P (src) && !register_operand (src, VOIDmode))
+       return FALSE;
+
+      if (side_effects_p (src) || side_effects_p (dest))
+       return FALSE;
+
+      if (may_trap_p (src) || may_trap_p (dest))
+       return FALSE;
+
+      /* Don't try to handle this if the destination register was
+        modified earlier in the block.  */
+      if (vals[REGNO (dest)] != NULL)
+       return FALSE;
+
+      /* Don't try to handle this if the condition uses the
+        destination register.  */
+      if (reg_overlap_mentioned_p (dest, cond))
+       return FALSE;
+
+      vals[REGNO (dest)] = src;
+
+      /* Don't try to handle this if the source register is modified
+        later in the block.  */
+      if (!CONSTANT_P (src)
+         && modified_between_p (src, insn, NEXT_INSN (BB_END (bb))))
+       return FALSE;
+    }
+
+  return TRUE;
+}
+
+/* Given a simple IF-THEN or IF-THEN-ELSE block, attempt to convert it
+   using only conditional moves.  Return TRUE if we were successful at
+   converting the block.  */
+
+static int
+cond_move_process_if_block (struct ce_if_block *ce_info)
+{
+  basic_block then_bb = ce_info->then_bb;
+  basic_block else_bb = ce_info->else_bb;
+  struct noce_if_info if_info;
+  rtx jump, cond, insn, seq, cond_arg0, cond_arg1, loc_insn;
+  int max_reg, size, c, i;
+  rtx *then_vals;
+  rtx *else_vals;
+  enum rtx_code code;
+
+  if (!HAVE_conditional_move || no_new_pseudos)
+    return FALSE;
+
+  memset (&if_info, 0, sizeof if_info);
+
+  if (!noce_init_if_info (ce_info, &if_info))
+    return FALSE;
+
+  cond = if_info.cond;
+  jump = if_info.jump;
+
+  /* Build a mapping for each block to the value used for each
+     register.  */
+  max_reg = max_reg_num ();
+  size = (max_reg + 1) * sizeof (rtx);
+  then_vals = (rtx *) alloca (size);
+  else_vals = (rtx *) alloca (size);
+  memset (then_vals, 0, size);
+  memset (else_vals, 0, size);
+
+  /* Make sure the blocks are suitable.  */
+  if (!check_cond_move_block (then_bb, then_vals, cond)
+      || (else_bb && !check_cond_move_block (else_bb, else_vals, cond)))
+    return FALSE;
+
+  /* Make sure the blocks can be used together.  If the same register
+     is set in both blocks, and is not set to a constant in both
+     cases, then both blocks must set it to the same register.  We
+     have already verified that if it is set to a register, that the
+     source register does not change after the assignment.  Also count
+     the number of registers set in only one of the blocks.  */
+  c = 0;
+  for (i = 0; i <= max_reg; ++i)
+    {
+      if (!then_vals[i] && !else_vals[i])
+       continue;
+
+      if (!then_vals[i] || !else_vals[i])
+       ++c;
+      else
+       {
+         if (!CONSTANT_P (then_vals[i])
+             && !CONSTANT_P (else_vals[i])
+             && !rtx_equal_p (then_vals[i], else_vals[i]))
+           return FALSE;
+       }
+    }
+
+  /* Make sure it is reasonable to convert this block.  What matters
+     is the number of assignments currently made in only one of the
+     branches, since if we convert we are going to always execute
+     them.  */
+  if (c > MAX_CONDITIONAL_EXECUTE)
+    return FALSE;
+
+  /* Emit the conditional moves.  First do the then block, then do
+     anything left in the else blocks.  */
+
+  code = GET_CODE (cond);
+  cond_arg0 = XEXP (cond, 0);
+  cond_arg1 = XEXP (cond, 1);
+
+  start_sequence ();
+
+  FOR_BB_INSNS (then_bb, insn)
+    {
+      rtx set, target, dest, t, e;
+      unsigned int regno;
+
+      if (!INSN_P (insn) || JUMP_P (insn))
+       continue;
+      set = single_set (insn);
+      gcc_assert (set && REG_P (SET_DEST (set)));
+
+      dest = SET_DEST (set);
+      regno = REGNO (dest);
+      t = then_vals[regno];
+      e = else_vals[regno];
+      gcc_assert (t);
+      if (!e)
+       e = dest;
+      target = noce_emit_cmove (&if_info, dest, code, cond_arg0, cond_arg1,
+                               t, e);
+      if (!target)
+       {
+         end_sequence ();
+         return FALSE;
+       }
+
+      if (target != dest)
+       noce_emit_move_insn (dest, target);
+    }
+
+  if (else_bb)
+    {
+      FOR_BB_INSNS (else_bb, insn)
+       {
+         rtx set, target, dest;
+         unsigned int regno;
+
+         if (!INSN_P (insn) || JUMP_P (insn))
+           continue;
+         set = single_set (insn);
+         gcc_assert (set && REG_P (SET_DEST (set)));
+
+         dest = SET_DEST (set);
+         regno = REGNO (dest);
+
+         /* If this register was set in the then block, we already
+            handled this case above.  */
+         if (then_vals[regno])
+           continue;
+         gcc_assert (else_vals[regno]);
+
+         target = noce_emit_cmove (&if_info, dest, code, cond_arg0, cond_arg1,
+                                   dest, else_vals[regno]);
+         if (!target)
+           {
+             end_sequence ();
+             return FALSE;
+           }
+
+         if (target != dest)
+           noce_emit_move_insn (dest, target);
+       }
+    }
+
+  seq = end_ifcvt_sequence (&if_info);
+  if (!seq)
+    return FALSE;
+
+  loc_insn = first_active_insn (then_bb);
+  if (!loc_insn)
+    {
+      loc_insn = first_active_insn (else_bb);
+      gcc_assert (loc_insn);
+    }
+  emit_insn_before_setloc (seq, jump, INSN_LOCATOR (loc_insn));
+
+  FOR_BB_INSNS (then_bb, insn)
+    if (INSN_P (insn) && !JUMP_P (insn))
+      delete_insn (insn);
+  if (else_bb)
+    {
+      FOR_BB_INSNS (else_bb, insn)
+       if (INSN_P (insn) && !JUMP_P (insn))
+         delete_insn (insn);
+    }
+  delete_insn (jump);
+
+  merge_if_block (ce_info);
+
+  return TRUE;
+}
 \f
 /* Attempt to convert an IF-THEN or IF-THEN-ELSE block into
    straight line code.  Return true if successful.  */
 \f
 /* Attempt to convert an IF-THEN or IF-THEN-ELSE block into
    straight line code.  Return true if successful.  */
@@ -1965,6 +2601,10 @@ process_if_block (struct ce_if_block * ce_info)
       && noce_process_if_block (ce_info))
     return TRUE;
 
       && noce_process_if_block (ce_info))
     return TRUE;
 
+  if (HAVE_conditional_move
+      && cond_move_process_if_block (ce_info))
+    return TRUE;
+
   if (HAVE_conditional_execution && reload_completed)
     {
       /* If we have && and || tests, try to first handle combining the && and
   if (HAVE_conditional_execution && reload_completed)
     {
       /* If we have && and || tests, try to first handle combining the && and
@@ -2013,10 +2653,8 @@ merge_if_block (struct ce_if_block * ce_info)
        {
          bb = fallthru;
          fallthru = block_fallthru (bb);
        {
          bb = fallthru;
          fallthru = block_fallthru (bb);
-         if (post_dominators)
-           delete_from_dominance_info (post_dominators, bb);
          merge_blocks (combo_bb, bb);
          merge_blocks (combo_bb, bb);
-         num_removed_blocks++;
+         num_true_changes++;
        }
       while (bb != last_test_bb);
     }
        }
       while (bb != last_test_bb);
     }
@@ -2027,13 +2665,11 @@ merge_if_block (struct ce_if_block * ce_info)
 
   if (then_bb)
     {
 
   if (then_bb)
     {
-      if (combo_bb->global_live_at_end)
-       COPY_REG_SET (combo_bb->global_live_at_end,
-                     then_bb->global_live_at_end);
-      if (post_dominators)
-       delete_from_dominance_info (post_dominators, then_bb);
+      if (combo_bb->il.rtl->global_live_at_end)
+       COPY_REG_SET (combo_bb->il.rtl->global_live_at_end,
+                     then_bb->il.rtl->global_live_at_end);
       merge_blocks (combo_bb, then_bb);
       merge_blocks (combo_bb, then_bb);
-      num_removed_blocks++;
+      num_true_changes++;
     }
 
   /* The ELSE block, if it existed, had a label.  That label count
     }
 
   /* The ELSE block, if it existed, had a label.  That label count
@@ -2041,10 +2677,8 @@ merge_if_block (struct ce_if_block * ce_info)
      get their addresses taken.  */
   if (else_bb)
     {
      get their addresses taken.  */
   if (else_bb)
     {
-      if (post_dominators)
-       delete_from_dominance_info (post_dominators, else_bb);
       merge_blocks (combo_bb, else_bb);
       merge_blocks (combo_bb, else_bb);
-      num_removed_blocks++;
+      num_true_changes++;
     }
 
   /* If there was no join block reported, that means it was not adjacent
     }
 
   /* If there was no join block reported, that means it was not adjacent
@@ -2052,35 +2686,26 @@ merge_if_block (struct ce_if_block * ce_info)
 
   if (! join_bb)
     {
 
   if (! join_bb)
     {
-      rtx last = combo_bb->end;
+      rtx last = BB_END (combo_bb);
 
       /* The outgoing edge for the current COMBO block should already
         be correct.  Verify this.  */
 
       /* The outgoing edge for the current COMBO block should already
         be correct.  Verify this.  */
-      if (combo_bb->succ == NULL_EDGE)
-       {
-         if (find_reg_note (last, REG_NORETURN, NULL))
-           ;
-         else if (GET_CODE (last) == INSN
-                  && GET_CODE (PATTERN (last)) == TRAP_IF
-                  && TRAP_CONDITION (PATTERN (last)) == const_true_rtx)
-           ;
-         else
-           abort ();
-       }
+      if (EDGE_COUNT (combo_bb->succs) == 0)
+       gcc_assert (find_reg_note (last, REG_NORETURN, NULL)
+                   || (NONJUMP_INSN_P (last)
+                       && GET_CODE (PATTERN (last)) == TRAP_IF
+                       && (TRAP_CONDITION (PATTERN (last))
+                           == const_true_rtx)));
 
 
+      else
       /* There should still be something at the end of the THEN or ELSE
          blocks taking us to our final destination.  */
       /* There should still be something at the end of the THEN or ELSE
          blocks taking us to our final destination.  */
-      else if (GET_CODE (last) == JUMP_INSN)
-       ;
-      else if (combo_bb->succ->dest == EXIT_BLOCK_PTR
-              && GET_CODE (last) == CALL_INSN
-              && SIBLING_CALL_P (last))
-       ;
-      else if ((combo_bb->succ->flags & EDGE_EH)
-              && can_throw_internal (last))
-       ;
-      else
-       abort ();
+       gcc_assert (JUMP_P (last)
+                   || (EDGE_SUCC (combo_bb, 0)->dest == EXIT_BLOCK_PTR
+                       && CALL_P (last)
+                       && SIBLING_CALL_P (last))
+                   || ((EDGE_SUCC (combo_bb, 0)->flags & EDGE_EH)
+                       && can_throw_internal (last)));
     }
 
   /* The JOIN block may have had quite a number of other predecessors too.
     }
 
   /* The JOIN block may have had quite a number of other predecessors too.
@@ -2088,20 +2713,17 @@ merge_if_block (struct ce_if_block * ce_info)
      have only one remaining edge from our if-then-else diamond.  If there
      is more than one remaining edge, it must come from elsewhere.  There
      may be zero incoming edges if the THEN block didn't actually join
      have only one remaining edge from our if-then-else diamond.  If there
      is more than one remaining edge, it must come from elsewhere.  There
      may be zero incoming edges if the THEN block didn't actually join
-     back up (as with a call to abort).  */
-  else if ((join_bb->pred == NULL
-           || join_bb->pred->pred_next == NULL)
+     back up (as with a call to a non-return function).  */
+  else if (EDGE_COUNT (join_bb->preds) < 2
           && join_bb != EXIT_BLOCK_PTR)
     {
       /* We can merge the JOIN.  */
           && join_bb != EXIT_BLOCK_PTR)
     {
       /* We can merge the JOIN.  */
-      if (combo_bb->global_live_at_end)
-       COPY_REG_SET (combo_bb->global_live_at_end,
-                     join_bb->global_live_at_end);
+      if (combo_bb->il.rtl->global_live_at_end)
+       COPY_REG_SET (combo_bb->il.rtl->global_live_at_end,
+                     join_bb->il.rtl->global_live_at_end);
 
 
-      if (post_dominators)
-       delete_from_dominance_info (post_dominators, join_bb);
       merge_blocks (combo_bb, join_bb);
       merge_blocks (combo_bb, join_bb);
-      num_removed_blocks++;
+      num_true_changes++;
     }
   else
     {
     }
   else
     {
@@ -2109,13 +2731,12 @@ merge_if_block (struct ce_if_block * ce_info)
 
       /* The outgoing edge for the current COMBO block should already
         be correct.  Verify this.  */
 
       /* The outgoing edge for the current COMBO block should already
         be correct.  Verify this.  */
-      if (combo_bb->succ->succ_next != NULL_EDGE
-         || combo_bb->succ->dest != join_bb)
-       abort ();
+      gcc_assert (single_succ_p (combo_bb)
+                 && single_succ (combo_bb) == join_bb);
 
       /* Remove the jump and cruft from the end of the COMBO block.  */
       if (join_bb != EXIT_BLOCK_PTR)
 
       /* Remove the jump and cruft from the end of the COMBO block.  */
       if (join_bb != EXIT_BLOCK_PTR)
-       tidy_fallthru_edge (combo_bb->succ, combo_bb, join_bb);
+       tidy_fallthru_edge (single_succ_edge (combo_bb));
     }
 
   num_updated_if_blocks++;
     }
 
   num_updated_if_blocks++;
@@ -2134,11 +2755,12 @@ find_if_header (basic_block test_bb, int pass)
   edge else_edge;
 
   /* The kind of block we're looking for has exactly two successors.  */
   edge else_edge;
 
   /* The kind of block we're looking for has exactly two successors.  */
-  if ((then_edge = test_bb->succ) == NULL_EDGE
-      || (else_edge = then_edge->succ_next) == NULL_EDGE
-      || else_edge->succ_next != NULL_EDGE)
+  if (EDGE_COUNT (test_bb->succs) != 2)
     return NULL;
 
     return NULL;
 
+  then_edge = EDGE_SUCC (test_bb, 0);
+  else_edge = EDGE_SUCC (test_bb, 1);
+
   /* Neither edge should be abnormal.  */
   if ((then_edge->flags & EDGE_COMPLEX)
       || (else_edge->flags & EDGE_COMPLEX))
   /* Neither edge should be abnormal.  */
   if ((then_edge->flags & EDGE_COMPLEX)
       || (else_edge->flags & EDGE_COMPLEX))
@@ -2179,7 +2801,7 @@ find_if_header (basic_block test_bb, int pass)
       && find_cond_trap (test_bb, then_edge, else_edge))
     goto success;
 
       && find_cond_trap (test_bb, then_edge, else_edge))
     goto success;
 
-  if (post_dominators
+  if (dom_computed[CDI_POST_DOMINATORS] >= DOM_NO_FAST_QUERY
       && (! HAVE_conditional_execution || reload_completed))
     {
       if (find_if_case_1 (test_bb, then_edge, else_edge))
       && (! HAVE_conditional_execution || reload_completed))
     {
       if (find_if_case_1 (test_bb, then_edge, else_edge))
@@ -2191,8 +2813,8 @@ find_if_header (basic_block test_bb, int pass)
   return NULL;
 
  success:
   return NULL;
 
  success:
-  if (rtl_dump_file)
-    fprintf (rtl_dump_file, "Conversion succeeded on pass %d.\n", pass);
+  if (dump_file)
+    fprintf (dump_file, "Conversion succeeded on pass %d.\n", pass);
   return ce_info.test_bb;
 }
 
   return ce_info.test_bb;
 }
 
@@ -2210,17 +2832,16 @@ block_jumps_and_fallthru_p (basic_block cur_bb, basic_block target_bb)
   rtx insn;
   rtx end;
   int n_insns = 0;
   rtx insn;
   rtx end;
   int n_insns = 0;
+  edge_iterator ei;
 
   if (!cur_bb || !target_bb)
     return -1;
 
   /* If no edges, obviously it doesn't jump or fallthru.  */
 
   if (!cur_bb || !target_bb)
     return -1;
 
   /* If no edges, obviously it doesn't jump or fallthru.  */
-  if (cur_bb->succ == NULL_EDGE)
+  if (EDGE_COUNT (cur_bb->succs) == 0)
     return FALSE;
 
     return FALSE;
 
-  for (cur_edge = cur_bb->succ;
-       cur_edge != NULL_EDGE;
-       cur_edge = cur_edge->succ_next)
+  FOR_EACH_EDGE (cur_edge, ei, cur_bb->succs)
     {
       if (cur_edge->flags & EDGE_COMPLEX)
        /* Anything complex isn't what we want.  */
     {
       if (cur_edge->flags & EDGE_COMPLEX)
        /* Anything complex isn't what we want.  */
@@ -2243,16 +2864,16 @@ block_jumps_and_fallthru_p (basic_block cur_bb, basic_block target_bb)
      together for conditional execution support.  ??? we should support
      conditional execution support across calls for IA-64 some day, but
      for now it makes the code simpler.  */
      together for conditional execution support.  ??? we should support
      conditional execution support across calls for IA-64 some day, but
      for now it makes the code simpler.  */
-  end = cur_bb->end;
-  insn = cur_bb->head;
+  end = BB_END (cur_bb);
+  insn = BB_HEAD (cur_bb);
 
   while (insn != NULL_RTX)
     {
 
   while (insn != NULL_RTX)
     {
-      if (GET_CODE (insn) == CALL_INSN)
+      if (CALL_P (insn))
        return -1;
 
       if (INSN_P (insn)
        return -1;
 
       if (INSN_P (insn)
-         && GET_CODE (insn) != JUMP_INSN
+         && !JUMP_P (insn)
          && GET_CODE (PATTERN (insn)) != USE
          && GET_CODE (PATTERN (insn)) != CLOBBER)
        n_insns++;
          && GET_CODE (PATTERN (insn)) != USE
          && GET_CODE (PATTERN (insn)) != CLOBBER)
        n_insns++;
@@ -2277,12 +2898,9 @@ find_if_block (struct ce_if_block * ce_info)
   basic_block then_bb = ce_info->then_bb;
   basic_block else_bb = ce_info->else_bb;
   basic_block join_bb = NULL_BLOCK;
   basic_block then_bb = ce_info->then_bb;
   basic_block else_bb = ce_info->else_bb;
   basic_block join_bb = NULL_BLOCK;
-  edge then_succ = then_bb->succ;
-  edge else_succ = else_bb->succ;
-  int then_predecessors;
-  int else_predecessors;
   edge cur_edge;
   basic_block next;
   edge cur_edge;
   basic_block next;
+  edge_iterator ei;
 
   ce_info->last_test_bb = test_bb;
 
 
   ce_info->last_test_bb = test_bb;
 
@@ -2290,11 +2908,10 @@ find_if_block (struct ce_if_block * ce_info)
      were && tests (which jump to the else block) or || tests (which jump to
      the then block).  */
   if (HAVE_conditional_execution && reload_completed
      were && tests (which jump to the else block) or || tests (which jump to
      the then block).  */
   if (HAVE_conditional_execution && reload_completed
-      && test_bb->pred != NULL_EDGE
-      && test_bb->pred->pred_next == NULL_EDGE
-      && test_bb->pred->flags == EDGE_FALLTHRU)
+      && single_pred_p (test_bb)
+      && single_pred_edge (test_bb)->flags == EDGE_FALLTHRU)
     {
     {
-      basic_block bb = test_bb->pred->src;
+      basic_block bb = single_pred (test_bb);
       basic_block target_bb;
       int max_insns = MAX_CONDITIONAL_EXECUTE;
       int n_insns;
       basic_block target_bb;
       int max_insns = MAX_CONDITIONAL_EXECUTE;
       int n_insns;
@@ -2327,10 +2944,10 @@ find_if_block (struct ce_if_block * ce_info)
              total_insns += n_insns;
              blocks++;
 
              total_insns += n_insns;
              blocks++;
 
-             if (bb->pred == NULL_EDGE || bb->pred->pred_next != NULL_EDGE)
+             if (!single_pred_p (bb))
                break;
 
                break;
 
-             bb = bb->pred->src;
+             bb = single_pred (bb);
              n_insns = block_jumps_and_fallthru_p (bb, target_bb);
            }
          while (n_insns >= 0 && (total_insns + n_insns) <= max_insns);
              n_insns = block_jumps_and_fallthru_p (bb, target_bb);
            }
          while (n_insns >= 0 && (total_insns + n_insns) <= max_insns);
@@ -2345,37 +2962,29 @@ find_if_block (struct ce_if_block * ce_info)
        }
     }
 
        }
     }
 
-  /* Count the number of edges the THEN and ELSE blocks have.  */
-  then_predecessors = 0;
-  for (cur_edge = then_bb->pred;
-       cur_edge != NULL_EDGE;
-       cur_edge = cur_edge->pred_next)
+  /* The THEN block of an IF-THEN combo must have exactly one predecessor,
+     other than any || blocks which jump to the THEN block.  */
+  if ((EDGE_COUNT (then_bb->preds) - ce_info->num_or_or_blocks) != 1)
+    return FALSE;
+    
+  /* The edges of the THEN and ELSE blocks cannot have complex edges.  */
+  FOR_EACH_EDGE (cur_edge, ei, then_bb->preds)
     {
     {
-      then_predecessors++;
       if (cur_edge->flags & EDGE_COMPLEX)
        return FALSE;
     }
 
       if (cur_edge->flags & EDGE_COMPLEX)
        return FALSE;
     }
 
-  else_predecessors = 0;
-  for (cur_edge = else_bb->pred;
-       cur_edge != NULL_EDGE;
-       cur_edge = cur_edge->pred_next)
+  FOR_EACH_EDGE (cur_edge, ei, else_bb->preds)
     {
     {
-      else_predecessors++;
       if (cur_edge->flags & EDGE_COMPLEX)
        return FALSE;
     }
 
       if (cur_edge->flags & EDGE_COMPLEX)
        return FALSE;
     }
 
-  /* The THEN block of an IF-THEN combo must have exactly one predecessor,
-     other than any || blocks which jump to the THEN block.  */
-  if ((then_predecessors - ce_info->num_or_or_blocks) != 1)
-    return FALSE;
-
   /* The THEN block of an IF-THEN combo must have zero or one successors.  */
   /* The THEN block of an IF-THEN combo must have zero or one successors.  */
-  if (then_succ != NULL_EDGE
-      && (then_succ->succ_next != NULL_EDGE
-          || (then_succ->flags & EDGE_COMPLEX)
-         || (flow2_completed && tablejump_p (then_bb->end, NULL, NULL))))
+  if (EDGE_COUNT (then_bb->succs) > 0
+      && (!single_succ_p (then_bb)
+          || (single_succ_edge (then_bb)->flags & EDGE_COMPLEX)
+         || (flow2_completed && tablejump_p (BB_END (then_bb), NULL, NULL))))
     return FALSE;
 
   /* If the THEN block has no successors, conditional execution can still
     return FALSE;
 
   /* If the THEN block has no successors, conditional execution can still
@@ -2384,19 +2993,19 @@ find_if_block (struct ce_if_block * ce_info)
      Check for the last insn of the THEN block being an indirect jump, which
      is listed as not having any successors, but confuses the rest of the CE
      code processing.  ??? we should fix this in the future.  */
      Check for the last insn of the THEN block being an indirect jump, which
      is listed as not having any successors, but confuses the rest of the CE
      code processing.  ??? we should fix this in the future.  */
-  if (then_succ == NULL)
+  if (EDGE_COUNT (then_bb->succs) == 0)
     {
     {
-      if (else_bb->pred->pred_next == NULL_EDGE)
+      if (single_pred_p (else_bb))
        {
        {
-         rtx last_insn = then_bb->end;
+         rtx last_insn = BB_END (then_bb);
 
          while (last_insn
 
          while (last_insn
-                && GET_CODE (last_insn) == NOTE
-                && last_insn != then_bb->head)
+                && NOTE_P (last_insn)
+                && last_insn != BB_HEAD (then_bb))
            last_insn = PREV_INSN (last_insn);
 
          if (last_insn
            last_insn = PREV_INSN (last_insn);
 
          if (last_insn
-             && GET_CODE (last_insn) == JUMP_INSN
+             && JUMP_P (last_insn)
              && ! simplejump_p (last_insn))
            return FALSE;
 
              && ! simplejump_p (last_insn))
            return FALSE;
 
@@ -2409,7 +3018,7 @@ find_if_block (struct ce_if_block * ce_info)
 
   /* If the THEN block's successor is the other edge out of the TEST block,
      then we have an IF-THEN combo without an ELSE.  */
 
   /* If the THEN block's successor is the other edge out of the TEST block,
      then we have an IF-THEN combo without an ELSE.  */
-  else if (then_succ->dest == else_bb)
+  else if (single_succ (then_bb) == else_bb)
     {
       join_bb = else_bb;
       else_bb = NULL_BLOCK;
     {
       join_bb = else_bb;
       else_bb = NULL_BLOCK;
@@ -2418,13 +3027,12 @@ find_if_block (struct ce_if_block * ce_info)
   /* If the THEN and ELSE block meet in a subsequent block, and the ELSE
      has exactly one predecessor and one successor, and the outgoing edge
      is not complex, then we have an IF-THEN-ELSE combo.  */
   /* If the THEN and ELSE block meet in a subsequent block, and the ELSE
      has exactly one predecessor and one successor, and the outgoing edge
      is not complex, then we have an IF-THEN-ELSE combo.  */
-  else if (else_succ != NULL_EDGE
-          && then_succ->dest == else_succ->dest
-          && else_bb->pred->pred_next == NULL_EDGE
-          && else_succ->succ_next == NULL_EDGE
-          && ! (else_succ->flags & EDGE_COMPLEX)
-          && ! (flow2_completed && tablejump_p (else_bb->end, NULL, NULL)))
-    join_bb = else_succ->dest;
+  else if (single_succ_p (else_bb)
+          && single_succ (then_bb) == single_succ (else_bb)
+          && single_pred_p (else_bb)
+          && ! (single_succ_edge (else_bb)->flags & EDGE_COMPLEX)
+          && ! (flow2_completed && tablejump_p (BB_END (else_bb), NULL, NULL)))
+    join_bb = single_succ (else_bb);
 
   /* Otherwise it is not an IF-THEN or IF-THEN-ELSE combination.  */
   else
 
   /* Otherwise it is not an IF-THEN or IF-THEN-ELSE combination.  */
   else
@@ -2432,32 +3040,38 @@ find_if_block (struct ce_if_block * ce_info)
 
   num_possible_if_blocks++;
 
 
   num_possible_if_blocks++;
 
-  if (rtl_dump_file)
+  if (dump_file)
     {
     {
-      fprintf (rtl_dump_file, "\nIF-THEN%s block found, pass %d, start block %d [insn %d], then %d [%d]",
+      fprintf (dump_file,
+              "\nIF-THEN%s block found, pass %d, start block %d "
+              "[insn %d], then %d [%d]",
               (else_bb) ? "-ELSE" : "",
               ce_info->pass,
               (else_bb) ? "-ELSE" : "",
               ce_info->pass,
-              test_bb->index, (test_bb->head) ? (int)INSN_UID (test_bb->head) : -1,
-              then_bb->index, (then_bb->head) ? (int)INSN_UID (then_bb->head) : -1);
+              test_bb->index,
+              BB_HEAD (test_bb) ? (int)INSN_UID (BB_HEAD (test_bb)) : -1,
+              then_bb->index,
+              BB_HEAD (then_bb) ? (int)INSN_UID (BB_HEAD (then_bb)) : -1);
 
       if (else_bb)
 
       if (else_bb)
-       fprintf (rtl_dump_file, ", else %d [%d]",
-                else_bb->index, (else_bb->head) ? (int)INSN_UID (else_bb->head) : -1);
+       fprintf (dump_file, ", else %d [%d]",
+                else_bb->index,
+                BB_HEAD (else_bb) ? (int)INSN_UID (BB_HEAD (else_bb)) : -1);
 
 
-      fprintf (rtl_dump_file, ", join %d [%d]",
-              join_bb->index, (join_bb->head) ? (int)INSN_UID (join_bb->head) : -1);
+      fprintf (dump_file, ", join %d [%d]",
+              join_bb->index,
+              BB_HEAD (join_bb) ? (int)INSN_UID (BB_HEAD (join_bb)) : -1);
 
       if (ce_info->num_multiple_test_blocks > 0)
 
       if (ce_info->num_multiple_test_blocks > 0)
-       fprintf (rtl_dump_file, ", %d %s block%s last test %d [%d]",
+       fprintf (dump_file, ", %d %s block%s last test %d [%d]",
                 ce_info->num_multiple_test_blocks,
                 (ce_info->and_and_p) ? "&&" : "||",
                 (ce_info->num_multiple_test_blocks == 1) ? "" : "s",
                 ce_info->last_test_bb->index,
                 ce_info->num_multiple_test_blocks,
                 (ce_info->and_and_p) ? "&&" : "||",
                 (ce_info->num_multiple_test_blocks == 1) ? "" : "s",
                 ce_info->last_test_bb->index,
-                ((ce_info->last_test_bb->head)
-                 ? (int)INSN_UID (ce_info->last_test_bb->head)
+                ((BB_HEAD (ce_info->last_test_bb))
+                 ? (int)INSN_UID (BB_HEAD (ce_info->last_test_bb))
                  : -1));
 
                  : -1));
 
-      fputc ('\n', rtl_dump_file);
+      fputc ('\n', dump_file);
     }
 
   /* Make sure IF, THEN, and ELSE, blocks are adjacent.  Actually, we get the
     }
 
   /* Make sure IF, THEN, and ELSE, blocks are adjacent.  Actually, we get the
@@ -2466,7 +3080,7 @@ find_if_block (struct ce_if_block * ce_info)
      we checked the FALLTHRU flag, those are already adjacent to the last IF
      block.  */
   /* ??? As an enhancement, move the ELSE block.  Have to deal with
      we checked the FALLTHRU flag, those are already adjacent to the last IF
      block.  */
   /* ??? As an enhancement, move the ELSE block.  Have to deal with
-     BLOCK notes, if by no other means than aborting the merge if they
+     BLOCK notes, if by no other means than backing out the merge if they
      exist.  Sticky enough I don't want to think about it now.  */
   next = then_bb;
   if (else_bb && (next = next->next_bb) != else_bb)
      exist.  Sticky enough I don't want to think about it now.  */
   next = then_bb;
   if (else_bb && (next = next->next_bb) != else_bb)
@@ -2508,14 +3122,14 @@ find_cond_trap (basic_block test_bb, edge then_edge, edge else_edge)
   else
     return FALSE;
 
   else
     return FALSE;
 
-  if (rtl_dump_file)
+  if (dump_file)
     {
     {
-      fprintf (rtl_dump_file, "\nTRAP-IF block found, start %d, trap %d\n",
+      fprintf (dump_file, "\nTRAP-IF block found, start %d, trap %d\n",
               test_bb->index, trap_bb->index);
     }
 
   /* If this is not a standard conditional jump, we can't parse it.  */
               test_bb->index, trap_bb->index);
     }
 
   /* If this is not a standard conditional jump, we can't parse it.  */
-  jump = test_bb->end;
+  jump = BB_END (test_bb);
   cond = noce_get_condition (jump, &cond_earliest);
   if (! cond)
     return FALSE;
   cond = noce_get_condition (jump, &cond_earliest);
   if (! cond)
     return FALSE;
@@ -2539,23 +3153,21 @@ find_cond_trap (basic_block test_bb, edge then_edge, edge else_edge)
     }
 
   /* Attempt to generate the conditional trap.  */
     }
 
   /* Attempt to generate the conditional trap.  */
-  seq = gen_cond_trap (code, XEXP (cond, 0), XEXP (cond, 1),
+  seq = gen_cond_trap (code, XEXP (cond, 0),
+                      XEXP (cond, 1),
                       TRAP_CODE (PATTERN (trap)));
   if (seq == NULL)
     return FALSE;
 
                       TRAP_CODE (PATTERN (trap)));
   if (seq == NULL)
     return FALSE;
 
+  num_true_changes++;
+
   /* Emit the new insns before cond_earliest.  */
   emit_insn_before_setloc (seq, cond_earliest, INSN_LOCATOR (trap));
 
   /* Delete the trap block if possible.  */
   remove_edge (trap_bb == then_bb ? then_edge : else_edge);
   /* Emit the new insns before cond_earliest.  */
   emit_insn_before_setloc (seq, cond_earliest, INSN_LOCATOR (trap));
 
   /* Delete the trap block if possible.  */
   remove_edge (trap_bb == then_bb ? then_edge : else_edge);
-  if (trap_bb->pred == NULL)
-    {
-      if (post_dominators)
-       delete_from_dominance_info (post_dominators, trap_bb);
-      delete_block (trap_bb);
-      num_removed_blocks++;
-    }
+  if (EDGE_COUNT (trap_bb->preds) == 0)
+    delete_basic_block (trap_bb);
 
   /* If the non-trap block and the test are now adjacent, merge them.
      Otherwise we must insert a direct branch.  */
 
   /* If the non-trap block and the test are now adjacent, merge them.
      Otherwise we must insert a direct branch.  */
@@ -2599,12 +3211,12 @@ block_has_only_trap (basic_block bb)
     return NULL_RTX;
 
   /* The block must have no successors.  */
     return NULL_RTX;
 
   /* The block must have no successors.  */
-  if (bb->succ)
+  if (EDGE_COUNT (bb->succs) > 0)
     return NULL_RTX;
 
   /* The only instruction in the THEN block must be the trap.  */
   trap = first_active_insn (bb);
     return NULL_RTX;
 
   /* The only instruction in the THEN block must be the trap.  */
   trap = first_active_insn (bb);
-  if (! (trap == bb->end
+  if (! (trap == BB_END (bb)
         && GET_CODE (PATTERN (trap)) == TRAP_IF
          && TRAP_CONDITION (PATTERN (trap)) == const_true_rtx))
     return NULL_RTX;
         && GET_CODE (PATTERN (trap)) == TRAP_IF
          && TRAP_CONDITION (PATTERN (trap)) == const_true_rtx))
     return NULL_RTX;
@@ -2694,19 +3306,37 @@ find_if_case_1 (basic_block test_bb, edge then_edge, edge else_edge)
 {
   basic_block then_bb = then_edge->dest;
   basic_block else_bb = else_edge->dest, new_bb;
 {
   basic_block then_bb = then_edge->dest;
   basic_block else_bb = else_edge->dest, new_bb;
-  edge then_succ = then_bb->succ;
   int then_bb_index;
 
   int then_bb_index;
 
+  /* If we are partitioning hot/cold basic blocks, we don't want to
+     mess up unconditional or indirect jumps that cross between hot
+     and cold sections.
+  
+     Basic block partitioning may result in some jumps that appear to
+     be optimizable (or blocks that appear to be mergeable), but which really 
+     must be left untouched (they are required to make it safely across 
+     partition boundaries).  See  the comments at the top of 
+     bb-reorder.c:partition_hot_cold_basic_blocks for complete details.  */
+
+  if ((BB_END (then_bb) 
+       && find_reg_note (BB_END (then_bb), REG_CROSSING_JUMP, NULL_RTX))
+      || (BB_END (test_bb)
+         && find_reg_note (BB_END (test_bb), REG_CROSSING_JUMP, NULL_RTX))
+      || (BB_END (else_bb)
+         && find_reg_note (BB_END (else_bb), REG_CROSSING_JUMP, 
+                           NULL_RTX)))
+    return FALSE;
+
   /* THEN has one successor.  */
   /* THEN has one successor.  */
-  if (!then_succ || then_succ->succ_next != NULL)
+  if (!single_succ_p (then_bb))
     return FALSE;
 
   /* THEN does not fall through, but is not strange either.  */
     return FALSE;
 
   /* THEN does not fall through, but is not strange either.  */
-  if (then_succ->flags & (EDGE_COMPLEX | EDGE_FALLTHRU))
+  if (single_succ_edge (then_bb)->flags & (EDGE_COMPLEX | EDGE_FALLTHRU))
     return FALSE;
 
   /* THEN has one predecessor.  */
     return FALSE;
 
   /* THEN has one predecessor.  */
-  if (then_bb->pred->pred_next != NULL)
+  if (!single_pred_p (then_bb))
     return FALSE;
 
   /* THEN must do something.  */
     return FALSE;
 
   /* THEN must do something.  */
@@ -2714,46 +3344,61 @@ find_if_case_1 (basic_block test_bb, edge then_edge, edge else_edge)
     return FALSE;
 
   num_possible_if_blocks++;
     return FALSE;
 
   num_possible_if_blocks++;
-  if (rtl_dump_file)
-    fprintf (rtl_dump_file,
+  if (dump_file)
+    fprintf (dump_file,
             "\nIF-CASE-1 found, start %d, then %d\n",
             test_bb->index, then_bb->index);
 
   /* THEN is small.  */
             "\nIF-CASE-1 found, start %d, then %d\n",
             test_bb->index, then_bb->index);
 
   /* THEN is small.  */
-  if (count_bb_insns (then_bb) > BRANCH_COST)
+  if (! cheap_bb_rtx_cost_p (then_bb, COSTS_N_INSNS (BRANCH_COST)))
     return FALSE;
 
   /* Registers set are dead, or are predicable.  */
   if (! dead_or_predicable (test_bb, then_bb, else_bb,
     return FALSE;
 
   /* Registers set are dead, or are predicable.  */
   if (! dead_or_predicable (test_bb, then_bb, else_bb,
-                           then_bb->succ->dest, 1))
+                           single_succ (then_bb), 1))
     return FALSE;
 
   /* Conversion went ok, including moving the insns and fixing up the
      jump.  Adjust the CFG to match.  */
 
     return FALSE;
 
   /* Conversion went ok, including moving the insns and fixing up the
      jump.  Adjust the CFG to match.  */
 
-  bitmap_operation (test_bb->global_live_at_end,
-                   else_bb->global_live_at_start,
-                   then_bb->global_live_at_end, BITMAP_IOR);
+  bitmap_ior (test_bb->il.rtl->global_live_at_end,
+             else_bb->il.rtl->global_live_at_start,
+             then_bb->il.rtl->global_live_at_end);
+
+
+  /* We can avoid creating a new basic block if then_bb is immediately
+     followed by else_bb, i.e. deleting then_bb allows test_bb to fall
+     thru to else_bb.  */
+
+  if (then_bb->next_bb == else_bb
+      && then_bb->prev_bb == test_bb
+      && else_bb != EXIT_BLOCK_PTR)
+    {
+      redirect_edge_succ (FALLTHRU_EDGE (test_bb), else_bb);
+      new_bb = 0;
+    }
+  else
+    new_bb = redirect_edge_and_branch_force (FALLTHRU_EDGE (test_bb),
+                                             else_bb);
 
 
-  new_bb = redirect_edge_and_branch_force (FALLTHRU_EDGE (test_bb), else_bb);
   then_bb_index = then_bb->index;
   then_bb_index = then_bb->index;
-  if (post_dominators)
-    delete_from_dominance_info (post_dominators, then_bb);
-  delete_block (then_bb);
+  delete_basic_block (then_bb);
 
   /* Make rest of code believe that the newly created block is the THEN_BB
      block we removed.  */
   if (new_bb)
     {
       new_bb->index = then_bb_index;
 
   /* Make rest of code believe that the newly created block is the THEN_BB
      block we removed.  */
   if (new_bb)
     {
       new_bb->index = then_bb_index;
-      BASIC_BLOCK (then_bb_index) = new_bb;
-      if (post_dominators)
-       add_to_dominance_info (post_dominators, new_bb);
+      SET_BASIC_BLOCK (then_bb_index, new_bb);
+      /* Since the fallthru edge was redirected from test_bb to new_bb,
+         we need to ensure that new_bb is in the same partition as
+         test bb (you can not fall through across section boundaries).  */
+      BB_COPY_PARTITION (new_bb, test_bb);
     }
   /* We've possibly created jump to next insn, cleanup_cfg will solve that
      later.  */
 
     }
   /* We've possibly created jump to next insn, cleanup_cfg will solve that
      later.  */
 
-  num_removed_blocks++;
+  num_true_changes++;
   num_updated_if_blocks++;
 
   return TRUE;
   num_updated_if_blocks++;
 
   return TRUE;
@@ -2766,44 +3411,65 @@ find_if_case_2 (basic_block test_bb, edge then_edge, edge else_edge)
 {
   basic_block then_bb = then_edge->dest;
   basic_block else_bb = else_edge->dest;
 {
   basic_block then_bb = then_edge->dest;
   basic_block else_bb = else_edge->dest;
-  edge else_succ = else_bb->succ;
+  edge else_succ;
   rtx note;
 
   rtx note;
 
+  /* If we are partitioning hot/cold basic blocks, we don't want to
+     mess up unconditional or indirect jumps that cross between hot
+     and cold sections.
+  
+     Basic block partitioning may result in some jumps that appear to
+     be optimizable (or blocks that appear to be mergeable), but which really 
+     must be left untouched (they are required to make it safely across 
+     partition boundaries).  See  the comments at the top of 
+     bb-reorder.c:partition_hot_cold_basic_blocks for complete details.  */
+
+  if ((BB_END (then_bb)
+       && find_reg_note (BB_END (then_bb), REG_CROSSING_JUMP, NULL_RTX))
+      || (BB_END (test_bb)
+         && find_reg_note (BB_END (test_bb), REG_CROSSING_JUMP, NULL_RTX))
+      || (BB_END (else_bb) 
+         && find_reg_note (BB_END (else_bb), REG_CROSSING_JUMP, 
+                           NULL_RTX)))
+    return FALSE;
+
   /* ELSE has one successor.  */
   /* ELSE has one successor.  */
-  if (!else_succ || else_succ->succ_next != NULL)
+  if (!single_succ_p (else_bb))
     return FALSE;
     return FALSE;
+  else
+    else_succ = single_succ_edge (else_bb);
 
   /* ELSE outgoing edge is not complex.  */
   if (else_succ->flags & EDGE_COMPLEX)
     return FALSE;
 
   /* ELSE has one predecessor.  */
 
   /* ELSE outgoing edge is not complex.  */
   if (else_succ->flags & EDGE_COMPLEX)
     return FALSE;
 
   /* ELSE has one predecessor.  */
-  if (else_bb->pred->pred_next != NULL)
+  if (!single_pred_p (else_bb))
     return FALSE;
 
   /* THEN is not EXIT.  */
     return FALSE;
 
   /* THEN is not EXIT.  */
-  if (then_bb->index < 0)
+  if (then_bb->index < NUM_FIXED_BLOCKS)
     return FALSE;
 
   /* ELSE is predicted or SUCC(ELSE) postdominates THEN.  */
     return FALSE;
 
   /* ELSE is predicted or SUCC(ELSE) postdominates THEN.  */
-  note = find_reg_note (test_bb->end, REG_BR_PROB, NULL_RTX);
+  note = find_reg_note (BB_END (test_bb), REG_BR_PROB, NULL_RTX);
   if (note && INTVAL (XEXP (note, 0)) >= REG_BR_PROB_BASE / 2)
     ;
   if (note && INTVAL (XEXP (note, 0)) >= REG_BR_PROB_BASE / 2)
     ;
-  else if (else_succ->dest->index < 0
-          || dominated_by_p (post_dominators, then_bb,
+  else if (else_succ->dest->index < NUM_FIXED_BLOCKS
+          || dominated_by_p (CDI_POST_DOMINATORS, then_bb,
                              else_succ->dest))
     ;
   else
     return FALSE;
 
   num_possible_if_blocks++;
                              else_succ->dest))
     ;
   else
     return FALSE;
 
   num_possible_if_blocks++;
-  if (rtl_dump_file)
-    fprintf (rtl_dump_file,
+  if (dump_file)
+    fprintf (dump_file,
             "\nIF-CASE-2 found, start %d, else %d\n",
             test_bb->index, else_bb->index);
 
   /* ELSE is small.  */
             "\nIF-CASE-2 found, start %d, else %d\n",
             test_bb->index, else_bb->index);
 
   /* ELSE is small.  */
-  if (count_bb_insns (else_bb) > BRANCH_COST)
+  if (! cheap_bb_rtx_cost_p (else_bb, COSTS_N_INSNS (BRANCH_COST)))
     return FALSE;
 
   /* Registers set are dead, or are predicable.  */
     return FALSE;
 
   /* Registers set are dead, or are predicable.  */
@@ -2813,15 +3479,13 @@ find_if_case_2 (basic_block test_bb, edge then_edge, edge else_edge)
   /* Conversion went ok, including moving the insns and fixing up the
      jump.  Adjust the CFG to match.  */
 
   /* Conversion went ok, including moving the insns and fixing up the
      jump.  Adjust the CFG to match.  */
 
-  bitmap_operation (test_bb->global_live_at_end,
-                   then_bb->global_live_at_start,
-                   else_bb->global_live_at_end, BITMAP_IOR);
+  bitmap_ior (test_bb->il.rtl->global_live_at_end,
+             then_bb->il.rtl->global_live_at_start,
+             else_bb->il.rtl->global_live_at_end);
 
 
-  if (post_dominators)
-    delete_from_dominance_info (post_dominators, else_bb);
-  delete_block (else_bb);
+  delete_basic_block (else_bb);
 
 
-  num_removed_blocks++;
+  num_true_changes++;
   num_updated_if_blocks++;
 
   /* ??? We may now fallthru from one of THEN's successors into a join
   num_updated_if_blocks++;
 
   /* ??? We may now fallthru from one of THEN's successors into a join
@@ -2836,7 +3500,7 @@ find_if_case_2 (basic_block test_bb, edge then_edge, edge else_edge)
 static int
 find_memory (rtx *px, void *data ATTRIBUTE_UNUSED)
 {
 static int
 find_memory (rtx *px, void *data ATTRIBUTE_UNUSED)
 {
-  return GET_CODE (*px) == MEM;
+  return MEM_P (*px);
 }
 
 /* Used by the code above to perform the actual rtl transformations.
 }
 
 /* Used by the code above to perform the actual rtl transformations.
@@ -2851,17 +3515,17 @@ static int
 dead_or_predicable (basic_block test_bb, basic_block merge_bb,
                    basic_block other_bb, basic_block new_dest, int reversep)
 {
 dead_or_predicable (basic_block test_bb, basic_block merge_bb,
                    basic_block other_bb, basic_block new_dest, int reversep)
 {
-  rtx head, end, jump, earliest, old_dest, new_label = NULL_RTX;
+  rtx head, end, jump, earliest = NULL_RTX, old_dest, new_label = NULL_RTX;
 
 
-  jump = test_bb->end;
+  jump = BB_END (test_bb);
 
   /* Find the extent of the real code in the merge block.  */
 
   /* Find the extent of the real code in the merge block.  */
-  head = merge_bb->head;
-  end = merge_bb->end;
+  head = BB_HEAD (merge_bb);
+  end = BB_END (merge_bb);
 
 
-  if (GET_CODE (head) == CODE_LABEL)
+  if (LABEL_P (head))
     head = NEXT_INSN (head);
     head = NEXT_INSN (head);
-  if (GET_CODE (head) == NOTE)
+  if (NOTE_P (head))
     {
       if (head == end)
        {
     {
       if (head == end)
        {
@@ -2871,7 +3535,7 @@ dead_or_predicable (basic_block test_bb, basic_block merge_bb,
       head = NEXT_INSN (head);
     }
 
       head = NEXT_INSN (head);
     }
 
-  if (GET_CODE (end) == JUMP_INSN)
+  if (JUMP_P (end))
     {
       if (head == end)
        {
     {
       if (head == end)
        {
@@ -2887,8 +3551,8 @@ dead_or_predicable (basic_block test_bb, basic_block merge_bb,
   if (HAVE_conditional_execution)
     {
       /* In the conditional execution case, we have things easy.  We know
   if (HAVE_conditional_execution)
     {
       /* In the conditional execution case, we have things easy.  We know
-        the condition is reversible.  We don't have to check life info,
-        becase we're going to conditionally execute the code anyway.
+        the condition is reversible.  We don't have to check life info
+        because we're going to conditionally execute the code anyway.
         All that's left is making sure the insns involved can actually
         be predicated.  */
 
         All that's left is making sure the insns involved can actually
         be predicated.  */
 
@@ -2927,15 +3591,15 @@ dead_or_predicable (basic_block test_bb, basic_block merge_bb,
         that any registers modified are dead at the branch site.  */
 
       rtx insn, cond, prev;
         that any registers modified are dead at the branch site.  */
 
       rtx insn, cond, prev;
-      regset_head merge_set_head, tmp_head, test_live_head, test_set_head;
       regset merge_set, tmp, test_live, test_set;
       struct propagate_block_info *pbi;
       regset merge_set, tmp, test_live, test_set;
       struct propagate_block_info *pbi;
-      int i, fail = 0;
+      unsigned i, fail = 0;
+      bitmap_iterator bi;
 
       /* Check for no calls or trapping operations.  */
       for (insn = head; ; insn = NEXT_INSN (insn))
        {
 
       /* Check for no calls or trapping operations.  */
       for (insn = head; ; insn = NEXT_INSN (insn))
        {
-         if (GET_CODE (insn) == CALL_INSN)
+         if (CALL_P (insn))
            return FALSE;
          if (INSN_P (insn))
            {
            return FALSE;
          if (INSN_P (insn))
            {
@@ -2968,34 +3632,41 @@ dead_or_predicable (basic_block test_bb, basic_block merge_bb,
           TEST_SET  = set of registers set between EARLIEST and the
                       end of the block.  */
 
           TEST_SET  = set of registers set between EARLIEST and the
                       end of the block.  */
 
-      tmp = INITIALIZE_REG_SET (tmp_head);
-      merge_set = INITIALIZE_REG_SET (merge_set_head);
-      test_live = INITIALIZE_REG_SET (test_live_head);
-      test_set = INITIALIZE_REG_SET (test_set_head);
+      tmp = ALLOC_REG_SET (&reg_obstack);
+      merge_set = ALLOC_REG_SET (&reg_obstack);
+      test_live = ALLOC_REG_SET (&reg_obstack);
+      test_set = ALLOC_REG_SET (&reg_obstack);
 
       /* ??? bb->local_set is only valid during calculate_global_regs_live,
         so we must recompute usage for MERGE_BB.  Not so bad, I suppose,
          since we've already asserted that MERGE_BB is small.  */
 
       /* ??? bb->local_set is only valid during calculate_global_regs_live,
         so we must recompute usage for MERGE_BB.  Not so bad, I suppose,
          since we've already asserted that MERGE_BB is small.  */
+      /* If we allocated new pseudos (e.g. in the conditional move
+        expander called from noce_emit_cmove), we must resize the
+        array first.  */
+      if (max_regno < max_reg_num ())
+       {
+         max_regno = max_reg_num ();
+         allocate_reg_info (max_regno, FALSE, FALSE);
+       }
       propagate_block (merge_bb, tmp, merge_set, merge_set, 0);
 
       /* For small register class machines, don't lengthen lifetimes of
         hard registers before reload.  */
       if (SMALL_REGISTER_CLASSES && ! reload_completed)
        {
       propagate_block (merge_bb, tmp, merge_set, merge_set, 0);
 
       /* For small register class machines, don't lengthen lifetimes of
         hard registers before reload.  */
       if (SMALL_REGISTER_CLASSES && ! reload_completed)
        {
-          EXECUTE_IF_SET_IN_BITMAP
-           (merge_set, 0, i,
-            {
-              if (i < FIRST_PSEUDO_REGISTER
-                  && ! fixed_regs[i]
-                  && ! global_regs[i])
+          EXECUTE_IF_SET_IN_BITMAP (merge_set, 0, i, bi)
+           {
+             if (i < FIRST_PSEUDO_REGISTER
+                 && ! fixed_regs[i]
+                 && ! global_regs[i])
                fail = 1;
                fail = 1;
-            });
+           }
        }
 
       /* For TEST, we're interested in a range of insns, not a whole block.
         Moreover, we're interested in the insns live from OTHER_BB.  */
 
        }
 
       /* For TEST, we're interested in a range of insns, not a whole block.
         Moreover, we're interested in the insns live from OTHER_BB.  */
 
-      COPY_REG_SET (test_live, other_bb->global_live_at_start);
+      COPY_REG_SET (test_live, other_bb->il.rtl->global_live_at_start);
       pbi = init_propagate_block_info (test_bb, test_live, test_set, test_set,
                                       0);
 
       pbi = init_propagate_block_info (test_bb, test_live, test_set, test_set,
                                       0);
 
@@ -3011,16 +3682,14 @@ dead_or_predicable (basic_block test_bb, basic_block merge_bb,
       /* We can perform the transformation if
           MERGE_SET & (TEST_SET | TEST_LIVE)
         and
       /* We can perform the transformation if
           MERGE_SET & (TEST_SET | TEST_LIVE)
         and
-          TEST_SET & merge_bb->global_live_at_start
+          TEST_SET & merge_bb->il.rtl->global_live_at_start
         are empty.  */
 
         are empty.  */
 
-      bitmap_operation (tmp, test_set, test_live, BITMAP_IOR);
-      bitmap_operation (tmp, tmp, merge_set, BITMAP_AND);
-      EXECUTE_IF_SET_IN_BITMAP(tmp, 0, i, fail = 1);
-
-      bitmap_operation (tmp, test_set, merge_bb->global_live_at_start,
-                       BITMAP_AND);
-      EXECUTE_IF_SET_IN_BITMAP(tmp, 0, i, fail = 1);
+      if (bitmap_intersect_p (test_set, merge_set)
+         || bitmap_intersect_p (test_live, merge_set)
+         || bitmap_intersect_p (test_set,
+                                merge_bb->il.rtl->global_live_at_start))
+       fail = 1;
 
       FREE_REG_SET (tmp);
       FREE_REG_SET (merge_set);
 
       FREE_REG_SET (tmp);
       FREE_REG_SET (merge_set);
@@ -3051,13 +3720,7 @@ dead_or_predicable (basic_block test_bb, basic_block merge_bb,
 
   if (other_bb != new_dest)
     {
 
   if (other_bb != new_dest)
     {
-      if (old_dest)
-       LABEL_NUSES (old_dest) -= 1;
-      if (new_label)
-       LABEL_NUSES (new_label) += 1;
-      JUMP_LABEL (jump) = new_label;
-      if (reversep)
-       invert_br_probabilities (jump);
+      redirect_jump_2 (jump, old_dest, new_label, -1, reversep);
 
       redirect_edge_succ (BRANCH_EDGE (test_bb), new_dest);
       if (reversep)
 
       redirect_edge_succ (BRANCH_EDGE (test_bb), new_dest);
       if (reversep)
@@ -3077,12 +3740,31 @@ dead_or_predicable (basic_block test_bb, basic_block merge_bb,
   /* Move the insns out of MERGE_BB to before the branch.  */
   if (head != NULL)
     {
   /* Move the insns out of MERGE_BB to before the branch.  */
   if (head != NULL)
     {
-      if (end == merge_bb->end)
-       merge_bb->end = PREV_INSN (head);
+      rtx insn;
+
+      if (end == BB_END (merge_bb))
+       BB_END (merge_bb) = PREV_INSN (head);
 
       if (squeeze_notes (&head, &end))
        return TRUE;
 
 
       if (squeeze_notes (&head, &end))
        return TRUE;
 
+      /* PR 21767: When moving insns above a conditional branch, REG_EQUAL
+        notes might become invalid.  */
+      insn = head;
+      do
+       {
+         rtx note, set;
+
+         if (! INSN_P (insn))
+           continue;
+         note = find_reg_note (insn, REG_EQUAL, NULL_RTX);
+         if (! note)
+           continue;
+         set = single_set (insn);
+         if (!set || !function_invariant_p (SET_SRC (set)))
+           remove_note (insn, note);
+       } while (insn != end && (insn = NEXT_INSN (insn)));
+
       reorder_insns (head, end, PREV_INSN (earliest));
     }
 
       reorder_insns (head, end, PREV_INSN (earliest));
     }
 
@@ -3104,7 +3786,7 @@ dead_or_predicable (basic_block test_bb, basic_block merge_bb,
 \f
 /* Main entry point for all if-conversion.  */
 
 \f
 /* Main entry point for all if-conversion.  */
 
-void
+static void
 if_convert (int x_life_data_ok)
 {
   basic_block bb;
 if_convert (int x_life_data_ok)
 {
   basic_block bb;
@@ -3112,22 +3794,25 @@ if_convert (int x_life_data_ok)
 
   num_possible_if_blocks = 0;
   num_updated_if_blocks = 0;
 
   num_possible_if_blocks = 0;
   num_updated_if_blocks = 0;
-  num_removed_blocks = 0;
+  num_true_changes = 0;
   life_data_ok = (x_life_data_ok != 0);
 
   life_data_ok = (x_life_data_ok != 0);
 
-  if (! (* targetm.cannot_modify_jumps_p) ())
-    mark_loop_exit_edges ();
+  if ((! targetm.cannot_modify_jumps_p ())
+      && (!flag_reorder_blocks_and_partition || !no_new_pseudos
+         || !targetm.have_named_sections))
+    {
+      struct loops loops;
 
 
-  /* Free up basic_block_for_insn so that we don't have to keep it
-     up to date, either here or in merge_blocks.  */
-  free_basic_block_vars (1);
+      flow_loops_find (&loops);
+      mark_loop_exit_edges (&loops);
+      flow_loops_free (&loops);
+      free_dominance_info (CDI_DOMINATORS);
+    }
 
   /* Compute postdominators if we think we'll use them.  */
 
   /* Compute postdominators if we think we'll use them.  */
-  post_dominators = NULL;
   if (HAVE_conditional_execution || life_data_ok)
   if (HAVE_conditional_execution || life_data_ok)
-    {
-      post_dominators = calculate_dominance_info (CDI_POST_DOMINATORS);
-    }
+    calculate_dominance_info (CDI_POST_DOMINATORS);
+
   if (life_data_ok)
     clear_bb_flags ();
 
   if (life_data_ok)
     clear_bb_flags ();
 
@@ -3141,8 +3826,8 @@ if_convert (int x_life_data_ok)
       pass++;
 
 #ifdef IFCVT_MULTIPLE_DUMPS
       pass++;
 
 #ifdef IFCVT_MULTIPLE_DUMPS
-      if (rtl_dump_file && pass > 1)
-       fprintf (rtl_dump_file, "\n\n========== Pass %d ==========\n", pass);
+      if (dump_file && pass > 1)
+       fprintf (dump_file, "\n\n========== Pass %d ==========\n", pass);
 #endif
 
       FOR_EACH_BB (bb)
 #endif
 
       FOR_EACH_BB (bb)
@@ -3153,27 +3838,26 @@ if_convert (int x_life_data_ok)
        }
 
 #ifdef IFCVT_MULTIPLE_DUMPS
        }
 
 #ifdef IFCVT_MULTIPLE_DUMPS
-      if (rtl_dump_file && cond_exec_changed_p)
-       print_rtl_with_bb (rtl_dump_file, get_insns ());
+      if (dump_file && cond_exec_changed_p)
+       print_rtl_with_bb (dump_file, get_insns ());
 #endif
     }
   while (cond_exec_changed_p);
 
 #ifdef IFCVT_MULTIPLE_DUMPS
 #endif
     }
   while (cond_exec_changed_p);
 
 #ifdef IFCVT_MULTIPLE_DUMPS
-  if (rtl_dump_file)
-    fprintf (rtl_dump_file, "\n\n========== no more changes\n");
+  if (dump_file)
+    fprintf (dump_file, "\n\n========== no more changes\n");
 #endif
 
 #endif
 
-  if (post_dominators)
-    free_dominance_info (post_dominators);
+  free_dominance_info (CDI_POST_DOMINATORS);
 
 
-  if (rtl_dump_file)
-    fflush (rtl_dump_file);
+  if (dump_file)
+    fflush (dump_file);
 
   clear_aux_for_blocks ();
 
   /* Rebuild life info for basic blocks that require it.  */
 
   clear_aux_for_blocks ();
 
   /* Rebuild life info for basic blocks that require it.  */
-  if (num_removed_blocks && life_data_ok)
+  if (num_true_changes && life_data_ok)
     {
       /* If we allocated new pseudos, we must resize the array for sched1.  */
       if (max_regno < max_reg_num ())
     {
       /* If we allocated new pseudos, we must resize the array for sched1.  */
       if (max_regno < max_reg_num ())
@@ -3187,20 +3871,137 @@ if_convert (int x_life_data_ok)
     }
 
   /* Write the final stats.  */
     }
 
   /* Write the final stats.  */
-  if (rtl_dump_file && num_possible_if_blocks > 0)
+  if (dump_file && num_possible_if_blocks > 0)
     {
     {
-      fprintf (rtl_dump_file,
+      fprintf (dump_file,
               "\n%d possible IF blocks searched.\n",
               num_possible_if_blocks);
               "\n%d possible IF blocks searched.\n",
               num_possible_if_blocks);
-      fprintf (rtl_dump_file,
+      fprintf (dump_file,
               "%d IF blocks converted.\n",
               num_updated_if_blocks);
               "%d IF blocks converted.\n",
               num_updated_if_blocks);
-      fprintf (rtl_dump_file,
-              "%d basic blocks deleted.\n\n\n",
-              num_removed_blocks);
+      fprintf (dump_file,
+              "%d true changes made.\n\n\n",
+              num_true_changes);
     }
 
 #ifdef ENABLE_CHECKING
   verify_flow_info ();
 #endif
 }
     }
 
 #ifdef ENABLE_CHECKING
   verify_flow_info ();
 #endif
 }
+\f
+static bool
+gate_handle_if_conversion (void)
+{
+  return (optimize > 0);
+}
+
+/* If-conversion and CFG cleanup.  */
+static void
+rest_of_handle_if_conversion (void)
+{
+  if (flag_if_conversion)
+    {
+      if (dump_file)
+        dump_flow_info (dump_file, dump_flags);
+      cleanup_cfg (CLEANUP_EXPENSIVE);
+      reg_scan (get_insns (), max_reg_num ());
+      if_convert (0);
+    }
+
+  timevar_push (TV_JUMP);
+  cleanup_cfg (CLEANUP_EXPENSIVE);
+  reg_scan (get_insns (), max_reg_num ());
+  timevar_pop (TV_JUMP);
+}
+
+struct tree_opt_pass pass_rtl_ifcvt =
+{
+  "ce1",                                /* name */
+  gate_handle_if_conversion,            /* gate */
+  rest_of_handle_if_conversion,         /* execute */
+  NULL,                                 /* sub */
+  NULL,                                 /* next */
+  0,                                    /* static_pass_number */
+  TV_IFCVT,                             /* tv_id */
+  0,                                    /* properties_required */
+  0,                                    /* properties_provided */
+  0,                                    /* properties_destroyed */
+  0,                                    /* todo_flags_start */
+  TODO_dump_func,                       /* todo_flags_finish */
+  'C'                                   /* letter */
+};
+
+static bool
+gate_handle_if_after_combine (void)
+{
+  return (optimize > 0 && flag_if_conversion);
+}
+
+
+/* Rerun if-conversion, as combine may have simplified things enough
+   to now meet sequence length restrictions.  */
+static void
+rest_of_handle_if_after_combine (void)
+{
+  no_new_pseudos = 0;
+  if_convert (1);
+  no_new_pseudos = 1;
+}
+
+struct tree_opt_pass pass_if_after_combine =
+{
+  "ce2",                                /* name */
+  gate_handle_if_after_combine,         /* gate */
+  rest_of_handle_if_after_combine,      /* execute */
+  NULL,                                 /* sub */
+  NULL,                                 /* next */
+  0,                                    /* static_pass_number */
+  TV_IFCVT,                             /* tv_id */
+  0,                                    /* properties_required */
+  0,                                    /* properties_provided */
+  0,                                    /* properties_destroyed */
+  0,                                    /* todo_flags_start */
+  TODO_dump_func |
+  TODO_ggc_collect,                     /* todo_flags_finish */
+  'C'                                   /* letter */
+};
+
+
+static bool
+gate_handle_if_after_reload (void)
+{
+  return (optimize > 0);
+}
+
+static void
+rest_of_handle_if_after_reload (void)
+{
+  /* Last attempt to optimize CFG, as scheduling, peepholing and insn
+     splitting possibly introduced more crossjumping opportunities.  */
+  cleanup_cfg (CLEANUP_EXPENSIVE
+               | CLEANUP_UPDATE_LIFE
+               | (flag_crossjumping ? CLEANUP_CROSSJUMP : 0));
+  if (flag_if_conversion2)
+    if_convert (1);
+}
+
+
+struct tree_opt_pass pass_if_after_reload =
+{
+  "ce3",                                /* name */
+  gate_handle_if_after_reload,          /* gate */
+  rest_of_handle_if_after_reload,       /* execute */
+  NULL,                                 /* sub */
+  NULL,                                 /* next */
+  0,                                    /* static_pass_number */
+  TV_IFCVT2,                            /* tv_id */
+  0,                                    /* properties_required */
+  0,                                    /* properties_provided */
+  0,                                    /* properties_destroyed */
+  0,                                    /* todo_flags_start */
+  TODO_dump_func |
+  TODO_ggc_collect,                     /* todo_flags_finish */
+  'E'                                   /* letter */
+};
+
+