i386.md (movsicc, [...]): Delete unconstrained alternatives.

        Sun Jan 31 13:22:02 1999  John Wehle  (john@feith.com)
        * i386.md (movsicc, movhicc, movsfcc, movdfcc,
        movxfcc, movdicc): Delete unconstrained alternatives.
        * i386.c (output_fp_conditional_move,
        output_int_conditional_move): Delete unused case.

From-SVN: r25179

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 58d34e610aa77535b12f1520c56bdb4bf32e847f..1d439076f52e546cf32e0e8c3ca2643d9404b6f7 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,5 +1,11 @@
 Sat Feb 13 11:53:12 1999  Jeffrey A Law  (law@cygnus.com)
 
+       Sun Jan 31 13:22:02 1999  John Wehle  (john@feith.com)
+       * i386.md (movsicc, movhicc, movsfcc, movdfcc,
+       movxfcc, movdicc): Delete unconstrained alternatives.
+       * i386.c (output_fp_conditional_move,
+       output_int_conditional_move): Delete unused case.
+
        Tue Aug 18 10:33:30 1998  Jeffrey A Law  (law@cygnus.com)
        * expr.c (emit_block_move): Do not call memcpy as a libcall
        instead build up a CALL_EXPR and call it like any other

diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c
index d3410635266806545f4fed9d119f2d49cf33a487..b2512a02980a6ba75e24d20c6d6457e503404d89 100644 (file)
--- a/gcc/config/i386/i386.c
+++ b/gcc/config/i386/i386.c
@@ -1,5 +1,5 @@
 /* Subroutines for insn-output.c for Intel X86.
-   Copyright (C) 1988, 92, 94, 95, 96, 97, 1998 Free Software Foundation, Inc.
+   Copyright (C) 1988, 92, 94-98, 1999 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -5208,12 +5208,6 @@ output_fp_conditional_move (which_alternative, operands)
       output_asm_insn (AS2 (fcmov%f1,%3,%0), operands);
       break;
 
-    case 2:
-      /* r <- cond ? r : arg */
-      output_asm_insn (AS2 (fcmov%F1,%2,%0), operands);
-      output_asm_insn (AS2 (fcmov%f1,%3,%0), operands);
-      break;
-
     default:
       abort ();
     }
@@ -5273,17 +5267,6 @@ output_int_conditional_move (which_alternative, operands)
        output_asm_insn (AS2 (cmov%c1,%3,%0), xops);
       break;
 
-    case 2:
-      /* rm <- cond ? arg1 : arg2 */
-      output_asm_insn (AS2 (cmov%C1,%2,%0), operands);
-      output_asm_insn (AS2 (cmov%c1,%3,%0), operands);
-      if (mode == DImode)
-       {
-         output_asm_insn (AS2 (cmov%C1,%2,%0), xops);
-         output_asm_insn (AS2 (cmov%c1,%3,%0), xops);
-       }
-      break;
-
     default:
       abort ();
     }

diff --git a/gcc/config/i386/i386.md b/gcc/config/i386/i386.md
index 189da0a0367bb19f7a10a0115cfda46982cb0c0e..f85992fd2ca3b9c0d10ca50b0923c199c0159f06 100644 (file)
--- a/gcc/config/i386/i386.md
+++ b/gcc/config/i386/i386.md
@@ -7238,32 +7238,32 @@ byte_xor_operation:
 }")
 
 (define_insn ""
-  [(set (match_operand:SI 0 "register_operand" "=r,r,r,r,&r,&r")
+  [(set (match_operand:SI 0 "register_operand" "=r,r,r,r")
        (if_then_else:SI (match_operator 1 "comparison_operator" 
-             [(match_operand:QI 2 "nonimmediate_operand" "q,m,q,m,q,m")
-               (match_operand:QI 3 "general_operand" "qmn,qn,qmn,qn,qmn,qn")])
-             (match_operand:SI 4 "nonimmediate_operand" "rm,rm,0,0,rm,rm")
-             (match_operand:SI 5 "nonimmediate_operand" "0,0,rm,rm,rm,rm")))]
+             [(match_operand:QI 2 "nonimmediate_operand" "q,m,q,m")
+               (match_operand:QI 3 "general_operand" "qmn,qn,qmn,qn")])
+             (match_operand:SI 4 "nonimmediate_operand" "rm,rm,0,0")
+             (match_operand:SI 5 "nonimmediate_operand" "0,0,rm,rm")))]
   "TARGET_CMOVE"
   "#")
 
 (define_insn ""
-  [(set (match_operand:SI 0 "register_operand" "=r,r,r,r,&r,&r")
+  [(set (match_operand:SI 0 "register_operand" "=r,r,r,r")
        (if_then_else:SI (match_operator 1 "comparison_operator" 
-             [(match_operand 2 "nonimmediate_operand" "r,m,r,m,r,m")
-               (match_operand 3 "general_operand" "rmi,ri,rmi,ri,rmi,ri")])
-             (match_operand:SI 4 "nonimmediate_operand" "rm,rm,0,0,rm,rm")
-             (match_operand:SI 5 "nonimmediate_operand" "0,0,rm,rm,rm,rm")))]
+             [(match_operand 2 "nonimmediate_operand" "r,m,r,m")
+               (match_operand 3 "general_operand" "rmi,ri,rmi,ri")])
+             (match_operand:SI 4 "nonimmediate_operand" "rm,rm,0,0")
+             (match_operand:SI 5 "nonimmediate_operand" "0,0,rm,rm")))]
   "TARGET_CMOVE && GET_MODE_CLASS (GET_MODE (operands[2])) == MODE_INT"
   "#")
 
 (define_split
-  [(set (match_operand:SI 0 "register_operand" "=r,r,&r")
+  [(set (match_operand:SI 0 "register_operand" "=r,r")
        (if_then_else:SI (match_operator 1 "comparison_operator" 
                                [(match_operand 2 "nonimmediate_operand" "")
                                 (const_int 0)])
-                     (match_operand:SI 3 "nonimmediate_operand" "rm,0,rm")
-                     (match_operand:SI 4 "nonimmediate_operand" "0,rm,rm")))]
+                     (match_operand:SI 3 "nonimmediate_operand" "rm,0")
+                     (match_operand:SI 4 "nonimmediate_operand" "0,rm")))]
   "TARGET_CMOVE && reload_completed"
   [(set (cc0)
        (match_dup 2))
@@ -7273,12 +7273,12 @@ byte_xor_operation:
   "")
 
 (define_split
-  [(set (match_operand:SI 0 "register_operand" "=r,r,&r")
+  [(set (match_operand:SI 0 "register_operand" "=r,r")
        (if_then_else:SI (match_operator 1 "comparison_operator" 
                                [(match_operand 2 "nonimmediate_operand" "")
                                 (match_operand 3 "general_operand" "")])
-                     (match_operand:SI 4 "nonimmediate_operand" "rm,0,rm")
-                     (match_operand:SI 5 "nonimmediate_operand" "0,rm,rm")))]
+                     (match_operand:SI 4 "nonimmediate_operand" "rm,0")
+                     (match_operand:SI 5 "nonimmediate_operand" "0,rm")))]
   "TARGET_CMOVE && reload_completed"
   [(set (cc0) (compare (match_dup 2) (match_dup 3)))
    (set (match_dup 0)
@@ -7287,11 +7287,11 @@ byte_xor_operation:
   "")
 
 (define_insn ""
-  [(set (match_operand:SI 0 "register_operand" "=r,r,&r")
+  [(set (match_operand:SI 0 "register_operand" "=r,r")
        (if_then_else:SI (match_operator 1 "comparison_operator" 
                                [(cc0) (const_int 0)])
-                     (match_operand:SI 2 "nonimmediate_operand" "rm,0,rm")
-                     (match_operand:SI 3 "nonimmediate_operand" "0,rm,rm")))]
+                     (match_operand:SI 2 "nonimmediate_operand" "rm,0")
+                     (match_operand:SI 3 "nonimmediate_operand" "0,rm")))]
   "TARGET_CMOVE && reload_completed"
   "* return output_int_conditional_move (which_alternative, operands);")
 
@@ -7312,32 +7312,32 @@ byte_xor_operation:
 }")
 
 (define_insn ""
-  [(set (match_operand:HI 0 "register_operand" "=r,r,r,r,&r,&r")
+  [(set (match_operand:HI 0 "register_operand" "=r,r,r,r")
        (if_then_else:HI (match_operator 1 "comparison_operator" 
-             [(match_operand:QI 2 "nonimmediate_operand" "q,m,q,m,q,m")
-               (match_operand:QI 3 "general_operand" "qmn,qn,qmn,qn,qmn,qn")])
-             (match_operand:HI 4 "nonimmediate_operand" "rm,rm,0,0,rm,rm")
-             (match_operand:HI 5 "nonimmediate_operand" "0,0,rm,rm,rm,rm")))]
+             [(match_operand:QI 2 "nonimmediate_operand" "q,m,q,m")
+               (match_operand:QI 3 "general_operand" "qmn,qn,qmn,qn")])
+             (match_operand:HI 4 "nonimmediate_operand" "rm,rm,0,0")
+             (match_operand:HI 5 "nonimmediate_operand" "0,0,rm,rm")))]
   "TARGET_CMOVE"
   "#")
 
 (define_insn ""
-  [(set (match_operand:HI 0 "register_operand" "=r,r,r,r,&r,&r")
+  [(set (match_operand:HI 0 "register_operand" "=r,r,r,r")
        (if_then_else:HI (match_operator 1 "comparison_operator" 
-             [(match_operand 2 "nonimmediate_operand" "r,m,r,m,r,m")
-               (match_operand 3 "general_operand" "rmi,ri,rmi,ri,rmi,ri")])
-             (match_operand:HI 4 "nonimmediate_operand" "rm,rm,0,0,rm,rm")
-             (match_operand:HI 5 "nonimmediate_operand" "0,0,rm,rm,rm,rm")))]
+             [(match_operand 2 "nonimmediate_operand" "r,m,r,m")
+               (match_operand 3 "general_operand" "rmi,ri,rmi,ri")])
+             (match_operand:HI 4 "nonimmediate_operand" "rm,rm,0,0")
+             (match_operand:HI 5 "nonimmediate_operand" "0,0,rm,rm")))]
   "TARGET_CMOVE && GET_MODE_CLASS (GET_MODE (operands[2])) == MODE_INT"
   "#")
 
 (define_split
-  [(set (match_operand:HI 0 "register_operand" "=r,r,&r")
+  [(set (match_operand:HI 0 "register_operand" "=r,r")
        (if_then_else:HI (match_operator 1 "comparison_operator" 
                                [(match_operand 2 "nonimmediate_operand" "")
                                 (const_int 0)])
-                     (match_operand:HI 3 "nonimmediate_operand" "rm,0,rm")
-                     (match_operand:HI 4 "nonimmediate_operand" "0,rm,rm")))]
+                     (match_operand:HI 3 "nonimmediate_operand" "rm,0")
+                     (match_operand:HI 4 "nonimmediate_operand" "0,rm")))]
   "TARGET_CMOVE && reload_completed"
   [(set (cc0)
        (match_dup 2))
@@ -7347,12 +7347,12 @@ byte_xor_operation:
   "")
 
 (define_split
-  [(set (match_operand:HI 0 "register_operand" "=r,r,&r")
+  [(set (match_operand:HI 0 "register_operand" "=r,r")
        (if_then_else:HI (match_operator 1 "comparison_operator" 
                                [(match_operand 2 "nonimmediate_operand" "")
                                 (match_operand 3 "general_operand" "")])
-                     (match_operand:HI 4 "nonimmediate_operand" "rm,0,rm")
-                     (match_operand:HI 5 "nonimmediate_operand" "0,rm,rm")))]
+                     (match_operand:HI 4 "nonimmediate_operand" "rm,0")
+                     (match_operand:HI 5 "nonimmediate_operand" "0,rm")))]
   "TARGET_CMOVE && reload_completed"
   [(set (cc0)
        (compare (match_dup 2) (match_dup 3)))
@@ -7362,11 +7362,11 @@ byte_xor_operation:
   "")
 
 (define_insn ""
-  [(set (match_operand:HI 0 "register_operand" "=r,r,&r")
+  [(set (match_operand:HI 0 "register_operand" "=r,r")
        (if_then_else:HI (match_operator 1 "comparison_operator" 
                                [(cc0) (const_int 0)])
-                     (match_operand:HI 2 "nonimmediate_operand" "rm,0,rm")
-                     (match_operand:HI 3 "nonimmediate_operand" "0,rm,rm")))]
+                     (match_operand:HI 2 "nonimmediate_operand" "rm,0")
+                     (match_operand:HI 3 "nonimmediate_operand" "0,rm")))]
   "TARGET_CMOVE && reload_completed"
   "* return output_int_conditional_move (which_alternative, operands);")
 
@@ -7411,36 +7411,36 @@ byte_xor_operation:
 }")
 
 (define_insn ""
-  [(set (match_operand:SF 0 "register_operand" "=f,f,f,f,f,f")
+  [(set (match_operand:SF 0 "register_operand" "=f,f,f,f")
        (if_then_else:SF (match_operator 1 "comparison_operator" 
-             [(match_operand:QI 2 "nonimmediate_operand" "q,m,q,m,q,m")
-               (match_operand:QI 3 "general_operand" "qmn,qn,qmn,qn,qmn,qn")])
-             (match_operand:SF 4 "register_operand" "f,f,0,0,f,f")
-             (match_operand:SF 5 "register_operand" "0,0,f,f,f,f")))]
+             [(match_operand:QI 2 "nonimmediate_operand" "q,m,q,m")
+               (match_operand:QI 3 "general_operand" "qmn,qn,qmn,qn")])
+             (match_operand:SF 4 "register_operand" "f,f,0,0")
+             (match_operand:SF 5 "register_operand" "0,0,f,f")))]
   "TARGET_CMOVE
     && GET_CODE (operands[1]) != LT && GET_CODE (operands[1]) != LE
     && GET_CODE (operands[1]) != GE && GET_CODE (operands[1]) != GT"
   "#")
 
 (define_insn ""
-  [(set (match_operand:SF 0 "register_operand" "=f,f,f,f,f,f")
+  [(set (match_operand:SF 0 "register_operand" "=f,f,f,f")
        (if_then_else:SF (match_operator 1 "comparison_operator" 
-               [(match_operand 2 "nonimmediate_operand" "r,m,r,m,r,m")
-                (match_operand 3 "general_operand" "rmi,ri,rmi,ri,rmi,ri")])
-             (match_operand:SF 4 "register_operand" "f,f,0,0,f,f")
-             (match_operand:SF 5 "register_operand" "0,0,f,f,f,f")))]
+               [(match_operand 2 "nonimmediate_operand" "r,m,r,m")
+                (match_operand 3 "general_operand" "rmi,ri,rmi,ri")])
+             (match_operand:SF 4 "register_operand" "f,f,0,0")
+             (match_operand:SF 5 "register_operand" "0,0,f,f")))]
   "TARGET_CMOVE && GET_MODE_CLASS (GET_MODE (operands[2])) == MODE_INT
     && GET_CODE (operands[1]) != LT && GET_CODE (operands[1]) != LE
     && GET_CODE (operands[1]) != GE && GET_CODE (operands[1]) != GT"
   "#")
 
 (define_split
-  [(set (match_operand:SF 0 "register_operand" "=f,f,f")
+  [(set (match_operand:SF 0 "register_operand" "=f,f")
        (if_then_else:SF (match_operator 1 "comparison_operator" 
                                [(match_operand 2 "nonimmediate_operand" "")
                                 (const_int 0)])
-                     (match_operand:SF 3 "register_operand" "f,0,f")
-                     (match_operand:SF 4 "register_operand" "0,f,f")))]
+                     (match_operand:SF 3 "register_operand" "f,0")
+                     (match_operand:SF 4 "register_operand" "0,f")))]
   "TARGET_CMOVE && reload_completed"
   [(set (cc0)
        (match_dup 2))
@@ -7450,12 +7450,12 @@ byte_xor_operation:
   "")
 
 (define_split
-  [(set (match_operand:SF 0 "register_operand" "=f,f,f")
+  [(set (match_operand:SF 0 "register_operand" "=f,f")
        (if_then_else:SF (match_operator 1 "comparison_operator" 
                                [(match_operand 2 "nonimmediate_operand" "")
                                 (match_operand 3 "general_operand" "")])
-                     (match_operand:SF 4 "register_operand" "f,0,f")
-                     (match_operand:SF 5 "register_operand" "0,f,f")))]
+                     (match_operand:SF 4 "register_operand" "f,0")
+                     (match_operand:SF 5 "register_operand" "0,f")))]
   "TARGET_CMOVE && reload_completed"
   [(set (cc0) (compare (match_dup 2) (match_dup 3)))
    (set (match_dup 0)
@@ -7464,11 +7464,11 @@ byte_xor_operation:
   "")
 
 (define_insn ""
-  [(set (match_operand:SF 0 "register_operand" "=f,f,f")
+  [(set (match_operand:SF 0 "register_operand" "=f,f")
        (if_then_else:SF (match_operator 1 "comparison_operator" 
                                [(cc0) (const_int 0)])
-                     (match_operand:SF 2 "register_operand" "f,0,f")
-                     (match_operand:SF 3 "register_operand" "0,f,f")))]
+                     (match_operand:SF 2 "register_operand" "f,0")
+                     (match_operand:SF 3 "register_operand" "0,f")))]
   "TARGET_CMOVE && reload_completed"
   "* return output_fp_conditional_move (which_alternative, operands);")
 
@@ -7513,36 +7513,36 @@ byte_xor_operation:
 }")
 
 (define_insn ""
-  [(set (match_operand:DF 0 "register_operand" "=f,f,f,f,f,f")
+  [(set (match_operand:DF 0 "register_operand" "=f,f,f,f")
        (if_then_else:DF (match_operator 1 "comparison_operator" 
-             [(match_operand:QI 2 "nonimmediate_operand" "q,m,q,m,q,m")
-               (match_operand:QI 3 "general_operand" "qmn,qn,qmn,qn,qmn,qn")])
-             (match_operand:DF 4 "register_operand" "f,f,0,0,f,f")
-             (match_operand:DF 5 "register_operand" "0,0,f,f,f,f")))]
+             [(match_operand:QI 2 "nonimmediate_operand" "q,m,q,m")
+               (match_operand:QI 3 "general_operand" "qmn,qn,qmn,qn")])
+             (match_operand:DF 4 "register_operand" "f,f,0,0")
+             (match_operand:DF 5 "register_operand" "0,0,f,f")))]
   "TARGET_CMOVE
     && GET_CODE (operands[1]) != LT && GET_CODE (operands[1]) != LE
     && GET_CODE (operands[1]) != GE && GET_CODE (operands[1]) != GT"
   "#")
 
 (define_insn ""
-  [(set (match_operand:DF 0 "register_operand" "=f,f,f,f,f,f")
+  [(set (match_operand:DF 0 "register_operand" "=f,f,f,f")
        (if_then_else:DF (match_operator 1 "comparison_operator" 
-             [(match_operand 2 "nonimmediate_operand" "r,m,r,m,r,m")
-               (match_operand 3 "general_operand" "rmi,ri,rmi,ri,rmi,ri")])
-             (match_operand:DF 4 "register_operand" "f,f,0,0,f,f")
-             (match_operand:DF 5 "register_operand" "0,0,f,f,f,f")))]
+             [(match_operand 2 "nonimmediate_operand" "r,m,r,m")
+               (match_operand 3 "general_operand" "rmi,ri,rmi,ri")])
+             (match_operand:DF 4 "register_operand" "f,f,0,0")
+             (match_operand:DF 5 "register_operand" "0,0,f,f")))]
   "TARGET_CMOVE && GET_MODE_CLASS (GET_MODE (operands[2])) == MODE_INT
     && GET_CODE (operands[1]) != LT && GET_CODE (operands[1]) != LE
     && GET_CODE (operands[1]) != GE && GET_CODE (operands[1]) != GT"
   "#")
 
 (define_split
-  [(set (match_operand:DF 0 "register_operand" "=f,f,f")
+  [(set (match_operand:DF 0 "register_operand" "=f,f")
        (if_then_else:DF (match_operator 1 "comparison_operator" 
                                [(match_operand 2 "nonimmediate_operand" "")
                                 (const_int 0)])
-                     (match_operand:DF 3 "register_operand" "f,0,f")
-                     (match_operand:DF 4 "register_operand" "0,f,f")))]
+                     (match_operand:DF 3 "register_operand" "f,0")
+                     (match_operand:DF 4 "register_operand" "0,f")))]
   "TARGET_CMOVE && reload_completed"
   [(set (cc0)
        (match_dup 2))
@@ -7552,12 +7552,12 @@ byte_xor_operation:
   "")
 
 (define_split
-  [(set (match_operand:DF 0 "register_operand" "=f,f,f")
+  [(set (match_operand:DF 0 "register_operand" "=f,f")
        (if_then_else:DF (match_operator 1 "comparison_operator" 
                                [(match_operand 2 "nonimmediate_operand" "")
                                 (match_operand 3 "general_operand" "")])
-                     (match_operand:DF 4 "register_operand" "f,0,f")
-                     (match_operand:DF 5 "register_operand" "0,f,f")))]
+                     (match_operand:DF 4 "register_operand" "f,0")
+                     (match_operand:DF 5 "register_operand" "0,f")))]
   "TARGET_CMOVE && reload_completed"
   [(set (cc0) (compare (match_dup 2) (match_dup 3)))
    (set (match_dup 0)
@@ -7566,11 +7566,11 @@ byte_xor_operation:
   "")
 
 (define_insn ""
-  [(set (match_operand:DF 0 "register_operand" "=f,f,f")
+  [(set (match_operand:DF 0 "register_operand" "=f,f")
        (if_then_else:DF (match_operator 1 "comparison_operator" 
                                [(cc0) (const_int 0)])
-                     (match_operand:DF 2 "register_operand" "f,0,f")
-                     (match_operand:DF 3 "register_operand" "0,f,f")))]
+                     (match_operand:DF 2 "register_operand" "f,0")
+                     (match_operand:DF 3 "register_operand" "0,f")))]
   "TARGET_CMOVE && reload_completed"
   "* return output_fp_conditional_move (which_alternative, operands);")
 
@@ -7615,36 +7615,36 @@ byte_xor_operation:
 }")
 
 (define_insn ""
-  [(set (match_operand:XF 0 "register_operand" "=f,f,f,f,f,f")
+  [(set (match_operand:XF 0 "register_operand" "=f,f,f,f")
        (if_then_else:XF (match_operator 1 "comparison_operator" 
-             [(match_operand:QI 2 "nonimmediate_operand" "q,m,q,m,q,m")
-               (match_operand:QI 3 "general_operand" "qmn,qn,qmn,qn,qmn,qn")])
-             (match_operand:XF 4 "register_operand" "f,f,0,0,f,f")
-             (match_operand:XF 5 "register_operand" "0,0,f,f,f,f")))]
+             [(match_operand:QI 2 "nonimmediate_operand" "q,m,q,m")
+               (match_operand:QI 3 "general_operand" "qmn,qn,qmn,qn")])
+             (match_operand:XF 4 "register_operand" "f,f,0,0")
+             (match_operand:XF 5 "register_operand" "0,0,f,f")))]
   "TARGET_CMOVE
     && GET_CODE (operands[1]) != LT && GET_CODE (operands[1]) != LE
     && GET_CODE (operands[1]) != GE && GET_CODE (operands[1]) != GT"
   "#")
 
 (define_insn ""
-  [(set (match_operand:XF 0 "register_operand" "=f,f,f,f,f,f")
+  [(set (match_operand:XF 0 "register_operand" "=f,f,f,f")
        (if_then_else:XF (match_operator 1 "comparison_operator" 
-             [(match_operand 2 "nonimmediate_operand" "r,m,r,m,r,m")
-               (match_operand 3 "general_operand" "rmi,ri,rmi,ri,rmi,ri")])
-             (match_operand:XF 4 "register_operand" "f,f,0,0,f,f")
-             (match_operand:XF 5 "register_operand" "0,0,f,f,f,f")))]
+             [(match_operand 2 "nonimmediate_operand" "r,m,r,m")
+               (match_operand 3 "general_operand" "rmi,ri,rmi,ri")])
+             (match_operand:XF 4 "register_operand" "f,f,0,0")
+             (match_operand:XF 5 "register_operand" "0,0,f,f")))]
   "TARGET_CMOVE && GET_MODE_CLASS (GET_MODE (operands[2])) == MODE_INT
     && GET_CODE (operands[1]) != LT && GET_CODE (operands[1]) != LE
     && GET_CODE (operands[1]) != GE && GET_CODE (operands[1]) != GT"
   "#")
 
 (define_split
-  [(set (match_operand:XF 0 "register_operand" "=f,f,f")
+  [(set (match_operand:XF 0 "register_operand" "=f,f")
        (if_then_else:XF (match_operator 1 "comparison_operator" 
                                [(match_operand 2 "nonimmediate_operand" "")
                                 (const_int 0)])
-                     (match_operand:XF 3 "register_operand" "f,0,f")
-                     (match_operand:XF 4 "register_operand" "0,f,f")))]
+                     (match_operand:XF 3 "register_operand" "f,0")
+                     (match_operand:XF 4 "register_operand" "0,f")))]
   "TARGET_CMOVE && reload_completed"
   [(set (cc0)
        (match_dup 2))
@@ -7654,12 +7654,12 @@ byte_xor_operation:
   "")
 
 (define_split
-  [(set (match_operand:XF 0 "register_operand" "=f,f,f")
+  [(set (match_operand:XF 0 "register_operand" "=f,f")
        (if_then_else:XF (match_operator 1 "comparison_operator" 
                                [(match_operand 2 "nonimmediate_operand" "")
                                 (match_operand 3 "general_operand" "")])
-                     (match_operand:XF 4 "register_operand" "f,0,f")
-                     (match_operand:XF 5 "register_operand" "0,f,f")))]
+                     (match_operand:XF 4 "register_operand" "f,0")
+                     (match_operand:XF 5 "register_operand" "0,f")))]
   "TARGET_CMOVE && reload_completed"
   [(set (cc0) (compare (match_dup 2) (match_dup 3)))
    (set (match_dup 0)
@@ -7668,11 +7668,11 @@ byte_xor_operation:
   "")
 
 (define_insn ""
-  [(set (match_operand:XF 0 "register_operand" "=f,f,f")
+  [(set (match_operand:XF 0 "register_operand" "=f,f")
        (if_then_else:XF (match_operator 1 "comparison_operator" 
                                [(cc0) (const_int 0)])
-                     (match_operand:XF 2 "register_operand" "f,0,f")
-                     (match_operand:XF 3 "register_operand" "0,f,f")))]
+                     (match_operand:XF 2 "register_operand" "f,0")
+                     (match_operand:XF 3 "register_operand" "0,f")))]
   "TARGET_CMOVE && reload_completed"
   "* return output_fp_conditional_move (which_alternative, operands);")
 
@@ -7693,32 +7693,32 @@ byte_xor_operation:
 }")
 
 (define_insn ""
-  [(set (match_operand:DI 0 "register_operand" "=&r,&r,&r,&r,&r,&r")
+  [(set (match_operand:DI 0 "register_operand" "=&r,&r,&r,&r")
        (if_then_else:DI (match_operator 1 "comparison_operator" 
-             [(match_operand:QI 2 "nonimmediate_operand" "q,m,q,m,q,m")
-               (match_operand:QI 3 "general_operand" "qmn,qn,qmn,qn,qmn,qn")])
-             (match_operand:DI 4 "nonimmediate_operand" "ro,ro,0,0,ro,ro")
-             (match_operand:DI 5 "nonimmediate_operand" "0,0,ro,ro,ro,ro")))]
+             [(match_operand:QI 2 "nonimmediate_operand" "q,m,q,m")
+               (match_operand:QI 3 "general_operand" "qmn,qn,qmn,qn")])
+             (match_operand:DI 4 "nonimmediate_operand" "ro,ro,0,0")
+             (match_operand:DI 5 "nonimmediate_operand" "0,0,ro,ro")))]
   "TARGET_CMOVE"
   "#")
 
 (define_insn ""
-  [(set (match_operand:DI 0 "register_operand" "=&r,&r,&r,&r,&r,&r")
+  [(set (match_operand:DI 0 "register_operand" "=&r,&r,&r,&r")
        (if_then_else:DI (match_operator 1 "comparison_operator" 
-             [(match_operand 2 "nonimmediate_operand" "r,m,r,m,r,m")
-               (match_operand 3 "general_operand" "rmi,ri,rmi,ri,rmi,ri")])
-             (match_operand:DI 4 "nonimmediate_operand" "ro,ro,0,0,ro,ro")
-             (match_operand:DI 5 "nonimmediate_operand" "0,0,ro,ro,ro,ro")))]
+             [(match_operand 2 "nonimmediate_operand" "r,m,r,m")
+               (match_operand 3 "general_operand" "rmi,ri,rmi,ri")])
+             (match_operand:DI 4 "nonimmediate_operand" "ro,ro,0,0")
+             (match_operand:DI 5 "nonimmediate_operand" "0,0,ro,ro")))]
   "TARGET_CMOVE && GET_MODE_CLASS (GET_MODE (operands[2])) == MODE_INT"
   "#")
 
 (define_split
-  [(set (match_operand:DI 0 "register_operand" "=&r,&r,&r")
+  [(set (match_operand:DI 0 "register_operand" "=&r,&r")
        (if_then_else:DI (match_operator 1 "comparison_operator" 
                                [(match_operand 2 "nonimmediate_operand" "")
                                 (const_int 0)])
-                     (match_operand:DI 3 "nonimmediate_operand" "ro,0,ro")
-                     (match_operand:DI 4 "nonimmediate_operand" "0,ro,ro")))]
+                     (match_operand:DI 3 "nonimmediate_operand" "ro,0")
+                     (match_operand:DI 4 "nonimmediate_operand" "0,ro")))]
   "TARGET_CMOVE && reload_completed"
   [(set (cc0)
        (match_dup 2))
@@ -7728,12 +7728,12 @@ byte_xor_operation:
   "")
 
 (define_split
-  [(set (match_operand:DI 0 "register_operand" "=&r,&r,&r")
+  [(set (match_operand:DI 0 "register_operand" "=&r,&r")
        (if_then_else:DI (match_operator 1 "comparison_operator" 
                                [(match_operand 2 "nonimmediate_operand" "")
                                 (match_operand 3 "general_operand" "")])
-                     (match_operand:DI 4 "nonimmediate_operand" "ro,0,ro")
-                     (match_operand:DI 5 "nonimmediate_operand" "0,ro,ro")))]
+                     (match_operand:DI 4 "nonimmediate_operand" "ro,0")
+                     (match_operand:DI 5 "nonimmediate_operand" "0,ro")))]
   "TARGET_CMOVE && reload_completed"
   [(set (cc0) (compare (match_dup 2) (match_dup 3)))
    (set (match_dup 0)
@@ -7742,11 +7742,11 @@ byte_xor_operation:
   "")
 
 (define_insn ""
-  [(set (match_operand:DI 0 "register_operand" "=&r,&r,&r")
+  [(set (match_operand:DI 0 "register_operand" "=&r,&r")
        (if_then_else:DI (match_operator 1 "comparison_operator" 
                                [(cc0) (const_int 0)])
-                     (match_operand:DI 2 "nonimmediate_operand" "ro,0,ro")
-                     (match_operand:DI 3 "nonimmediate_operand" "0,ro,ro")))]
+                     (match_operand:DI 2 "nonimmediate_operand" "ro,0")
+                     (match_operand:DI 3 "nonimmediate_operand" "0,ro")))]
   "TARGET_CMOVE && reload_completed"
   "* return output_int_conditional_move (which_alternative, operands);")