jump.c (jump_optimize_1): Use reversed_comparison_code instead of can_reverse_comparison_p.

	* jump.c (jump_optimize_1): Use reversed_comparison_code
	instead of can_reverse_comparison_p.
	(jump_back_p): Likewise.
	(invert_exp_1): Likewise.
	(thread_jumps): Likewise.
	* simplify-rtx.c (simplify_unary_operation): Likewise.
	(simplify_ternary_operation): Likewise.
	* cse.c (find_comparison_args): Convert to use
	can_reverse_comparison_p.
	(record_jump_equiv): Likewise.

From-SVN: r38802

gcc/ChangeLog

+Mon Jan  8 16:14:56 MET 2001  Jan Hubicka  <jh@suse.cz>
+
+	* jump.c (jump_optimize_1): Use reversed_comparison_code
+	instead of can_reverse_comparison_p.
+	(jump_back_p): Likewise.
+	(invert_exp_1): Likewise.
+	(thread_jumps): Likewise.
+	* simplify-rtx.c (simplify_unary_operation): Likewise.
+	(simplify_ternary_operation): Likewise.
+	* cse.c (find_comparison_args): Convert to use
+	can_reverse_comparison_p.
+	(record_jump_equiv): Likewise.
+
 2001-01-08  Richard Earnshaw  <rearnsha@arm.com>
 
 	* arm.h (HARD_REGNO_RENAME_OK): Delete.

gcc/cse.c

@@ -3251,15 +3251,16 @@ find_comparison_args (code, parg1, parg2, pmode1, pmode2)
       /* If we need to reverse the comparison, make sure that that is
 	 possible -- we can't necessarily infer the value of GE from LT
 	 with floating-point operands.  */
-      if (reverse_code && ! can_reverse_comparison_p (x, NULL_RTX))
-	break;
-
-      arg1 = XEXP (x, 0), arg2 = XEXP (x, 1);
-      if (GET_RTX_CLASS (GET_CODE (x)) == '<')
-	code = GET_CODE (x);
-
       if (reverse_code)
-	code = reverse_condition (code);
+	{
+	  enum rtx_code reversed = reversed_comparison_code (x, NULL_RTX);
+	  if (reversed == UNKNOWN)
+	    break;
+	  else code = reversed;
+	}
+      else if (GET_RTX_CLASS (GET_CODE (x)) == '<')
+	code = GET_CODE (x);
+      arg1 = XEXP (x, 0), arg2 = XEXP (x, 1);
     }
 
   /* Return our results.  Return the modes from before fold_rtx
@@ -4446,8 +4447,7 @@ record_jump_equiv (insn, taken)
   code = find_comparison_args (code, &op0, &op1, &mode0, &mode1);
   if (! cond_known_true)
     {
-      reversed_nonequality = (code != EQ && code != NE);
-      code = reverse_condition (code);
+      code = reversed_comparison_code_parts (code, op0, op1, insn);
 
       /* Don't remember if we can't find the inverse.  */
       if (code == UNKNOWN)

gcc/jump.c

@@ -207,6 +207,7 @@ jump_optimize_1 (f, cross_jump, noop_moves, after_regscan,
   int first = 1;
   int max_uid = 0;
   rtx last_insn;
+  enum rtx_code reversed_code;
 
   cross_jump_death_matters = (cross_jump == 2);
   max_uid = init_label_info (f) + 1;
@@ -525,9 +526,10 @@ jump_optimize_1 (f, cross_jump, noop_moves, after_regscan,
 	      && prev_active_insn (reallabelprev) == insn
 	      && no_labels_between_p (insn, reallabelprev)
 	      && (temp2 = get_condition (insn, &temp4))
-	      && can_reverse_comparison_p (temp2, insn))
+	      && ((reversed_code = reversed_comparison_code (temp2, insn))
+		  != UNKNOWN))
 	    {
-	      rtx new = gen_cond_trap (reverse_condition (GET_CODE (temp2)),
+	      rtx new = gen_cond_trap (reversed_code,
 				       XEXP (temp2, 0), XEXP (temp2, 1),
 				       TRAP_CODE (PATTERN (reallabelprev)));
 
@@ -1682,16 +1684,16 @@ jump_back_p (insn, target)
 
   if (XEXP (SET_SRC (set), 1) == pc_rtx)
     {
-      if (! can_reverse_comparison_p (cinsn, insn))
+      codei = reversed_comparison_code (cinsn, insn);
+      if (codei == UNKNOWN)
 	return 0;
-      codei = reverse_condition (codei);
     }
 
   if (XEXP (SET_SRC (tset), 2) == pc_rtx)
     {
-      if (! can_reverse_comparison_p (ctarget, target))
+      codet = reversed_comparison_code (ctarget, target);
+      if (codei == UNKNOWN)
 	return 0;
-      codet = reverse_condition (codet);
     }
 
   return (codei == codet
@@ -3319,16 +3321,19 @@ invert_exp_1 (insn)
     {
       register rtx comp = XEXP (x, 0);
       register rtx tem;
+      enum rtx_code reversed_code;
 
       /* We can do this in two ways:  The preferable way, which can only
 	 be done if this is not an integer comparison, is to reverse
 	 the comparison code.  Otherwise, swap the THEN-part and ELSE-part
 	 of the IF_THEN_ELSE.  If we can't do either, fail.  */
 
-      if (can_reverse_comparison_p (comp, insn))
+      reversed_code = reversed_comparison_code (comp, insn);
+
+      if (reversed_code != UNKNOWN)
 	{
 	  validate_change (insn, &XEXP (x, 0),
-			   gen_rtx_fmt_ee (reverse_condition (GET_CODE (comp)),
+			   gen_rtx_fmt_ee (reversed_code,
 					   GET_MODE (comp), XEXP (comp, 0),
 					   XEXP (comp, 1)),
 			   1);
@@ -3849,6 +3854,7 @@ thread_jumps (f, max_reg, flag_before_loop)
   int changed = 1;
   int i;
   int *all_reset;
+  enum rtx_code reversed_code1, reversed_code2;
 
   /* Allocate register tables and quick-reset table.  */
   modified_regs = (char *) xmalloc (max_reg * sizeof (char));
@@ -3938,14 +3944,20 @@ thread_jumps (f, max_reg, flag_before_loop)
 	  b1op0 = XEXP (XEXP (SET_SRC (set), 0), 0);
 	  b1op1 = XEXP (XEXP (SET_SRC (set), 0), 1);
 	  code1 = GET_CODE (XEXP (SET_SRC (set), 0));
+	  reversed_code1 = code1;
 	  if (XEXP (SET_SRC (set), 1) == pc_rtx)
-	    code1 = reverse_condition (code1);
+	    code1 = reversed_comparison_code (XEXP (SET_SRC (set), 0), b1);
+	  else
+	    reversed_code1 = reversed_comparison_code (XEXP (SET_SRC (set), 0), b1);
 
 	  b2op0 = XEXP (XEXP (SET_SRC (set2), 0), 0);
 	  b2op1 = XEXP (XEXP (SET_SRC (set2), 0), 1);
 	  code2 = GET_CODE (XEXP (SET_SRC (set2), 0));
+	  reversed_code2 = code2;
 	  if (XEXP (SET_SRC (set2), 1) == pc_rtx)
-	    code2 = reverse_condition (code2);
+	    code2 = reversed_comparison_code (XEXP (SET_SRC (set2), 0), b2);
+	  else
+	    reversed_code2 = reversed_comparison_code (XEXP (SET_SRC (set2), 0), b2);
 
 	  /* If they test the same things and knowing that B1 branches
 	     tells us whether or not B2 branches, check if we
@@ -3953,9 +3965,7 @@ thread_jumps (f, max_reg, flag_before_loop)
 	  if (rtx_equal_for_thread_p (b1op0, b2op0, b2)
 	      && rtx_equal_for_thread_p (b1op1, b2op1, b2)
 	      && (comparison_dominates_p (code1, code2)
-		  || (can_reverse_comparison_p (XEXP (SET_SRC (set), 0), b1)
-		      && comparison_dominates_p (code1,
-						 reverse_condition (code2)))))
+		  || comparison_dominates_p (code1, reversed_code2)))
 
 	    {
 	      t1 = prev_nonnote_insn (b1);

gcc/simplify-rtx.c

@@ -584,6 +584,7 @@ simplify_unary_operation (code, mode, op, op_mode)
      eggert@twinsun.com says it is safe for IEEE also.  */
   else
     {
+      enum rtx_code reversed;
       /* There are some simplifications we can do even if the operands
 	 aren't constant.  */
       switch (code)
@@ -595,8 +596,9 @@ simplify_unary_operation (code, mode, op, op_mode)
 
 	  /* (not (eq X Y)) == (ne X Y), etc.  */
 	  if (mode == BImode && GET_RTX_CLASS (GET_CODE (op)) == '<'
-	      && can_reverse_comparison_p (op, NULL_RTX))
-	    return gen_rtx_fmt_ee (reverse_condition (GET_CODE (op)),
+	      && ((reversed = reversed_comparison_code (op, NULL_RTX))
+		  != UNKNOWN))
+	    return gen_rtx_fmt_ee (reversed,
 				   op_mode, XEXP (op, 0), XEXP (op, 1));
 	  break;
 
@@ -2075,9 +2077,14 @@ simplify_ternary_operation (code, mode, op0_mode, op0, op1, op2)
 	      
 	      if (t == STORE_FLAG_VALUE && f == 0)
 	        code = GET_CODE (op0);
-	      else if (t == 0 && f == STORE_FLAG_VALUE
-		       && can_reverse_comparison_p (op0, NULL_RTX))
-		code = reverse_condition (GET_CODE (op0));
+	      else if (t == 0 && f == STORE_FLAG_VALUE)
+		{
+		  enum rtx_code tmp;
+		  tmp = reversed_comparison_code (op0, NULL_RTX);
+		  if (tmp == UNKNOWN)
+		    break;
+		  code = tmp;
+		}
 	      else
 		break;