[revert r192476 on 4.7-branch, to re-enable applying entire
 PR54146 backport <mikpe@it.uu.se>

gcc/

2012-10-21  Mikael Pettersson  <mikpe@it.uu.se>

	Revert:
	2012-10-15  Steven Bosscher  <steven@gcc.gnu.org>

	Backport from trunk (r190222):

	PR tree-optimization/54146
	* ifcvt.c: Include pointer-set.h.
	(cond_move_process_if_block): Change type of then_regs and
	else_regs from alloca'd array to pointer_sets.
	(check_cond_move_block): Update for this change.
	(cond_move_convert_if_block): Likewise.
	* Makefile.in: Fix dependencies for ifcvt.o.

--- gcc-4.7-20121020/gcc/Makefile.in.~1~	2012-10-15 23:31:57.000000000 +0200
+++ gcc-4.7-20121020/gcc/Makefile.in	2012-10-21 13:24:29.000000000 +0200
@@ -3417,7 +3417,7 @@ regrename.o : regrename.c $(CONFIG_H) $(
 ifcvt.o : ifcvt.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) \
    $(REGS_H) $(DIAGNOSTIC_CORE_H) $(FLAGS_H) insn-config.h $(FUNCTION_H) $(RECOG_H) \
    $(TARGET_H) $(BASIC_BLOCK_H) $(EXPR_H) output.h $(EXCEPT_H) $(TM_P_H) \
-   $(OPTABS_H) $(CFGLOOP_H) hard-reg-set.h pointer-set.h $(TIMEVAR_H) \
+   $(OPTABS_H) $(CFGLOOP_H) hard-reg-set.h $(TIMEVAR_H) \
    $(TREE_PASS_H) $(DF_H) $(DBGCNT_H)
 params.o : params.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(COMMON_TARGET_H) \
    $(PARAMS_H) $(DIAGNOSTIC_CORE_H)
--- gcc-4.7-20121020/gcc/ifcvt.c.~1~	2012-10-15 23:31:57.000000000 +0200
+++ gcc-4.7-20121020/gcc/ifcvt.c	2012-10-21 13:24:29.000000000 +0200
@@ -44,7 +44,6 @@
 #include "tree-pass.h"
 #include "df.h"
 #include "vec.h"
-#include "pointer-set.h"
 #include "vecprim.h"
 #include "dbgcnt.h"
 
@@ -2690,14 +2689,12 @@ noce_process_if_block (struct noce_if_in
 
 /* 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 pointer map
-   VALS, keyed indexed by register pointer, then store the register
-   pointer in REGS.  COND is the condition we will test.  */
+   register.  For each assignment, store the value in the array VALS,
+   indexed by register number, then store the register number in
+   REGS.  COND is the condition we will test.  */
 
 static int
-check_cond_move_block (basic_block bb,
-		       struct pointer_map_t *vals,
-		       VEC (rtx, heap) **regs,
+check_cond_move_block (basic_block bb, rtx *vals, VEC (int, heap) **regs,
 		       rtx cond)
 {
   rtx insn;
@@ -2711,7 +2708,6 @@ check_cond_move_block (basic_block bb,
   FOR_BB_INSNS (bb, insn)
     {
       rtx set, dest, src;
-      void **slot;
 
       if (!NONDEBUG_INSN_P (insn) || JUMP_P (insn))
 	continue;
@@ -2738,14 +2734,14 @@ check_cond_move_block (basic_block bb,
       /* Don't try to handle this if the source register was
 	 modified earlier in the block.  */
       if ((REG_P (src)
-	   && pointer_map_contains (vals, src))
+	   && vals[REGNO (src)] != NULL)
 	  || (GET_CODE (src) == SUBREG && REG_P (SUBREG_REG (src))
-	      && pointer_map_contains (vals, SUBREG_REG (src))))
+	      && vals[REGNO (SUBREG_REG (src))] != NULL))
 	return FALSE;
 
       /* Don't try to handle this if the destination register was
 	 modified earlier in the block.  */
-      if (pointer_map_contains (vals, dest))
+      if (vals[REGNO (dest)] != NULL)
 	return FALSE;
 
       /* Don't try to handle this if the condition uses the
@@ -2759,18 +2755,17 @@ check_cond_move_block (basic_block bb,
 	  && modified_between_p (src, insn, NEXT_INSN (BB_END (bb))))
 	return FALSE;
 
-      slot = pointer_map_insert (vals, (void *) dest);
-      *slot = (void *) src;
+      vals[REGNO (dest)] = src;
 
-      VEC_safe_push (rtx, heap, *regs, dest);
+      VEC_safe_push (int, heap, *regs, REGNO (dest));
     }
 
   return TRUE;
 }
 
 /* Given a basic block BB suitable for conditional move conversion,
-   a condition COND, and pointer maps THEN_VALS and ELSE_VALS containing
-   the register values depending on COND, emit the insns in the block as
+   a condition COND, and arrays THEN_VALS and ELSE_VALS containing the
+   register values depending on COND, emit the insns in the block as
    conditional moves.  If ELSE_BLOCK is true, THEN_BB was already
    processed.  The caller has started a sequence for the conversion.
    Return true if successful, false if something goes wrong.  */
@@ -2778,8 +2773,7 @@ check_cond_move_block (basic_block bb,
 static bool
 cond_move_convert_if_block (struct noce_if_info *if_infop,
 			    basic_block bb, rtx cond,
-			    struct pointer_map_t *then_vals,
-			    struct pointer_map_t *else_vals,
+			    rtx *then_vals, rtx *else_vals,
 			    bool else_block_p)
 {
   enum rtx_code code;
@@ -2792,7 +2786,7 @@ cond_move_convert_if_block (struct noce_
   FOR_BB_INSNS (bb, insn)
     {
       rtx set, target, dest, t, e;
-      void **then_slot, **else_slot;
+      unsigned int regno;
 
       /* ??? Maybe emit conditional debug insn?  */
       if (!NONDEBUG_INSN_P (insn) || JUMP_P (insn))
@@ -2801,11 +2795,10 @@ cond_move_convert_if_block (struct noce_
       gcc_assert (set && REG_P (SET_DEST (set)));
 
       dest = SET_DEST (set);
+      regno = REGNO (dest);
 
-      then_slot = pointer_map_contains (then_vals, dest);
-      else_slot = pointer_map_contains (else_vals, dest);
-      t = then_slot ? (rtx) *then_slot : NULL_RTX;
-      e = else_slot ? (rtx) *else_slot : NULL_RTX;
+      t = then_vals[regno];
+      e = else_vals[regno];
 
       if (else_block_p)
 	{
@@ -2849,25 +2842,31 @@ cond_move_process_if_block (struct noce_
   rtx jump = if_info->jump;
   rtx cond = if_info->cond;
   rtx seq, loc_insn;
-  rtx reg;
-  int c;
-  struct pointer_map_t *then_vals;
-  struct pointer_map_t *else_vals;
-  VEC (rtx, heap) *then_regs = NULL;
-  VEC (rtx, heap) *else_regs = NULL;
+  int max_reg, size, c, reg;
+  rtx *then_vals;
+  rtx *else_vals;
+  VEC (int, heap) *then_regs = NULL;
+  VEC (int, heap) *else_regs = NULL;
   unsigned int i;
-  int success_p = FALSE;
 
   /* Build a mapping for each block to the value used for each
      register.  */
-  then_vals = pointer_map_create ();
-  else_vals = pointer_map_create ();
+  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, &then_regs, cond)
       || (else_bb
 	  && !check_cond_move_block (else_bb, else_vals, &else_regs, cond)))
-    goto done;
+    {
+      VEC_free (int, heap, then_regs);
+      VEC_free (int, heap, else_regs);
+      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
@@ -2876,38 +2875,41 @@ cond_move_process_if_block (struct noce_
      source register does not change after the assignment.  Also count
      the number of registers set in only one of the blocks.  */
   c = 0;
-  FOR_EACH_VEC_ELT (rtx, then_regs, i, reg)
+  FOR_EACH_VEC_ELT (int, then_regs, i, reg)
     {
-      void **then_slot = pointer_map_contains (then_vals, reg);
-      void **else_slot = pointer_map_contains (else_vals, reg);
+      if (!then_vals[reg] && !else_vals[reg])
+	continue;
 
-      gcc_checking_assert (then_slot);
-      if (!else_slot)
+      if (!else_vals[reg])
 	++c;
       else
 	{
-	  rtx then_val = (rtx) *then_slot;
-	  rtx else_val = (rtx) *else_slot;
-	  if (!CONSTANT_P (then_val) && !CONSTANT_P (else_val)
-	      && !rtx_equal_p (then_val, else_val))
-	    goto done;
+	  if (!CONSTANT_P (then_vals[reg])
+	      && !CONSTANT_P (else_vals[reg])
+	      && !rtx_equal_p (then_vals[reg], else_vals[reg]))
+	    {
+	      VEC_free (int, heap, then_regs);
+	      VEC_free (int, heap, else_regs);
+	      return FALSE;
+	    }
 	}
     }
 
   /* Finish off c for MAX_CONDITIONAL_EXECUTE.  */
-  FOR_EACH_VEC_ELT (rtx, else_regs, i, reg)
-    {
-      gcc_checking_assert (pointer_map_contains (else_vals, reg));
-      if (!pointer_map_contains (then_vals, reg))
-	++c;
-    }
+  FOR_EACH_VEC_ELT (int, else_regs, i, reg)
+    if (!then_vals[reg])
+      ++c;
 
   /* 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)
-    goto done;
+    {
+      VEC_free (int, heap, then_regs);
+      VEC_free (int, heap, else_regs);
+      return FALSE;
+    }
 
   /* Try to emit the conditional moves.  First do the then block,
      then do anything left in the else blocks.  */
@@ -2919,11 +2921,17 @@ cond_move_process_if_block (struct noce_
 					  then_vals, else_vals, true)))
     {
       end_sequence ();
-      goto done;
+      VEC_free (int, heap, then_regs);
+      VEC_free (int, heap, else_regs);
+      return FALSE;
     }
   seq = end_ifcvt_sequence (if_info);
   if (!seq)
-    goto done;
+    {
+      VEC_free (int, heap, then_regs);
+      VEC_free (int, heap, else_regs);
+      return FALSE;
+    }
 
   loc_insn = first_active_insn (then_bb);
   if (!loc_insn)
@@ -2954,14 +2962,9 @@ cond_move_process_if_block (struct noce_
 
   num_updated_if_blocks++;
 
-  success_p = TRUE;
-
-done:
-  pointer_map_destroy (then_vals);
-  pointer_map_destroy (else_vals);
-  VEC_free (rtx, heap, then_regs);
-  VEC_free (rtx, heap, else_regs);
-  return success_p;
+  VEC_free (int, heap, then_regs);
+  VEC_free (int, heap, else_regs);
+  return TRUE;
 }
 
 
