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

	* 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

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 655af22aee63a56b49f6b0735520c2b25ccf5f5c..721b1c7097f0b3c78950110a8d896af60eec0df8 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,16 @@
+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.

diff --git a/gcc/cse.c b/gcc/cse.c
index d6c2025a0c26c272d5bad3091e04dc5848618743..3d0f1a7658c119d8693c388a3f96734bb2fbde51 100644 (file)
--- a/gcc/cse.c
+++ b/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)

diff --git a/gcc/jump.c b/gcc/jump.c
index 248c1d6dfd30f0beedb504e97f799f6655d4a6a8..15e41f0266f261ae61ccbbdf1c7f5b847e8f7170 100644 (file)
--- a/gcc/jump.c
+++ b/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);

diff --git a/gcc/simplify-rtx.c b/gcc/simplify-rtx.c
index a3a1bfea499bbda7e5c51e63c558b8c80f2afa73..9b0f79876ddee3b6eb621696da044a7a7368e0b6 100644 (file)
--- a/gcc/simplify-rtx.c
+++ b/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;