OSDN Git Service

(root) / pf3gnuchains / gcc-fork.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 9ba4400)
2002-09-12 Graham Stott <graham.stott@btinternet.com>
authorsayle <sayle@138bc75d-0d04-0410-961f-82ee72b054a4>
Thu, 12 Sep 2002 16:33:37 +0000 (16:33 +0000)
committersayle <sayle@138bc75d-0d04-0410-961f-82ee72b054a4>
Thu, 12 Sep 2002 16:33:37 +0000 (16:33 +0000)
            Roger Sayle  <roger@eyesopen.com>

* i386.c (any_fp_register_operand, fp_register_operand,
register_and_not_any_fp_reg_operand, register_and_not_fp_reg_operand):
New predicate functions.
* i386-protos.h:  Add their prototypes.
* i386.h: Add them to PREDICATE_CODES.
* i386.md ("*pushsf_rex64"+2, "*pushsf_rex64"+3, "*pushdf_integer"+1,
"*pushdf_integer"+2, "*pushtf_integer"+1, "*pushtf_integer"+2,
"*pushtf_integer"+3, "*pushtf_integer"+4, "*dummy_extendsfdf2"+1,
"*dummy_extendsfdf2"+2, "*dummy_extendsfxf2"+1,
"*dummy_extendsftf2"+1, "*dummy_extendsftf2"+2,
"*dummy_extenddfxf2"+1, "*dummy_extenddftf2"+1,
"*dummy_extenddftf2"+2, "*negsf2_if"+1, "*negsf2_if"+2,
"*negdf2_if_rex64"+1, "*negdf2_if_rex64"+2, "*negxf2_if"+1,
"*negxf2_if"+2, "*negtf2_if"+1, "*negtf2_if"+2, "*abssf2_if"+1,
"*abssf2_if"+2, "*absdf2_if_rex64"+1, "*absdf2_if_rex64"+2,
"*absxf2_if"+1, "*absxf2_if"+2, "*abstf2_if"+1, "*abstf2_if"+2):
Use these new predicates to simplify and correct the use of
FP_REG_P, ANY_FP_REG_P, FP_REGNO_P and any ANY_FP_REGNO_P.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@57068 138bc75d-0d04-0410-961f-82ee72b054a4

gcc/ChangeLog patch | blob | history
gcc/config/i386/i386-protos.h patch | blob | history
gcc/config/i386/i386.c patch | blob | history
gcc/config/i386/i386.h patch | blob | history
gcc/config/i386/i386.md patch | blob | history

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 5977a8d..20b5cee 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,25 @@
+2002-09-12  Graham Stott  <graham.stott@btinternet.com>
+            Roger Sayle  <roger@eyesopen.com>
+
+       * i386.c (any_fp_register_operand, fp_register_operand,
+       register_and_not_any_fp_reg_operand, register_and_not_fp_reg_operand):
+       New predicate functions.
+       * i386-protos.h:  Add their prototypes.
+       * i386.h: Add them to PREDICATE_CODES.
+       * i386.md ("*pushsf_rex64"+2, "*pushsf_rex64"+3, "*pushdf_integer"+1,
+       "*pushdf_integer"+2, "*pushtf_integer"+1, "*pushtf_integer"+2,
+       "*pushtf_integer"+3, "*pushtf_integer"+4, "*dummy_extendsfdf2"+1,
+       "*dummy_extendsfdf2"+2, "*dummy_extendsfxf2"+1,
+       "*dummy_extendsftf2"+1, "*dummy_extendsftf2"+2,
+       "*dummy_extenddfxf2"+1, "*dummy_extenddftf2"+1,
+       "*dummy_extenddftf2"+2, "*negsf2_if"+1, "*negsf2_if"+2,
+       "*negdf2_if_rex64"+1, "*negdf2_if_rex64"+2, "*negxf2_if"+1,
+       "*negxf2_if"+2, "*negtf2_if"+1, "*negtf2_if"+2, "*abssf2_if"+1,
+       "*abssf2_if"+2, "*absdf2_if_rex64"+1, "*absdf2_if_rex64"+2,
+       "*absxf2_if"+1, "*absxf2_if"+2, "*abstf2_if"+1, "*abstf2_if"+2):
+       Use these new predicates to simplify and correct the use of
+       FP_REG_P, ANY_FP_REG_P, FP_REGNO_P and any ANY_FP_REGNO_P.
+
 2002-09-12  Jason Merrill  <jason@redhat.com>
 
        * diagnostic.c (output_add_identifier): New fn.
diff --git a/gcc/config/i386/i386-protos.h b/gcc/config/i386/i386-protos.h
index bec35ae..1431c73 100644 (file)
--- a/gcc/config/i386/i386-protos.h
+++ b/gcc/config/i386/i386-protos.h
@@ -42,6 +42,12 @@ extern int standard_80387_constant_p PARAMS ((rtx));
 extern int standard_sse_constant_p PARAMS ((rtx));
 extern int symbolic_reference_mentioned_p PARAMS ((rtx));
 
+extern int any_fp_register_operand PARAMS ((rtx, enum machine_mode));
+extern int register_and_not_any_fp_reg_operand PARAMS ((rtx, enum machine_mode));
+
+extern int fp_register_operand PARAMS ((rtx, enum machine_mode));
+extern int register_and_not_fp_reg_operand PARAMS ((rtx, enum machine_mode));
+
 extern int x86_64_general_operand PARAMS ((rtx, enum machine_mode));
 extern int x86_64_szext_general_operand PARAMS ((rtx, enum machine_mode));
 extern int x86_64_nonmemory_operand PARAMS ((rtx, enum machine_mode));
diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c
index 81a9b97..4f62e4c 100644 (file)
--- a/gcc/config/i386/i386.c
+++ b/gcc/config/i386/i386.c
@@ -2754,6 +2754,43 @@ ix86_va_arg (valist, type)
   return addr_rtx;
 }
 \f
+/* Return nonzero if OP is either a i387 or SSE fp register.  */
+int
+any_fp_register_operand (op, mode)
+     rtx op;
+     enum machine_mode mode ATTRIBUTE_UNUSED;
+{
+  return ANY_FP_REG_P (op);
+}
+
+/* Return nonzero if OP is an i387 fp register.  */
+int
+fp_register_operand (op, mode)
+     rtx op;
+     enum machine_mode mode ATTRIBUTE_UNUSED;
+{
+  return FP_REG_P (op);
+}
+
+/* Return nonzero if OP is a non-fp register_operand.  */
+int
+register_and_not_any_fp_reg_operand (op, mode)
+     rtx op;
+     enum machine_mode mode;
+{
+  return register_operand (op, mode) && !ANY_FP_REG_P (op);
+}
+
+/* Return nonzero of OP is a register operand other than an
+   i387 fp register.  */
+int
+register_and_not_fp_reg_operand (op, mode)
+     rtx op;
+     enum machine_mode mode;
+{
+  return register_operand (op, mode) && !FP_REG_P (op);
+}
+
 /* Return nonzero if OP is general operand representable on x86_64.  */
 
 int
diff --git a/gcc/config/i386/i386.h b/gcc/config/i386/i386.h
index ddef1f9..fa55084 100644 (file)
--- a/gcc/config/i386/i386.h
+++ b/gcc/config/i386/i386.h
@@ -3203,7 +3203,11 @@ do {                                             \
   {"global_dynamic_symbolic_operand", {SYMBOL_REF}},                   \
   {"local_dynamic_symbolic_operand", {SYMBOL_REF}},                    \
   {"initial_exec_symbolic_operand", {SYMBOL_REF}},                     \
-  {"local_exec_symbolic_operand", {SYMBOL_REF}},
+  {"local_exec_symbolic_operand", {SYMBOL_REF}},                       \
+  {"any_fp_register_operand", {REG}},                                  \
+  {"register_and_not_any_fp_reg_operand", {REG}},                      \
+  {"fp_register_operand", {REG}},                                      \
+  {"register_and_not_fp_reg_operand", {REG}},                          \
 
 /* A list of predicates that do special things with modes, and so
    should not elicit warnings for VOIDmode match_operand.  */
diff --git a/gcc/config/i386/i386.md b/gcc/config/i386/i386.md
index a306509..c1d581d 100644 (file)
--- a/gcc/config/i386/i386.md
+++ b/gcc/config/i386/i386.md
@@ -2077,15 +2077,15 @@
 ;; %%% Kill this when call knows how to work this out.
 (define_split
   [(set (match_operand:SF 0 "push_operand" "")
-       (match_operand:SF 1 "register_operand" ""))]
-  "!TARGET_64BIT && ANY_FP_REGNO_P (REGNO (operands[1]))"
+       (match_operand:SF 1 "any_fp_register_operand" ""))]
+  "!TARGET_64BIT"
   [(set (reg:SI 7) (plus:SI (reg:SI 7) (const_int -4)))
    (set (mem:SF (reg:SI 7)) (match_dup 1))])
 
 (define_split
   [(set (match_operand:SF 0 "push_operand" "")
-       (match_operand:SF 1 "register_operand" ""))]
-  "TARGET_64BIT && ANY_FP_REGNO_P (REGNO (operands[1]))"
+       (match_operand:SF 1 "any_fp_register_operand" ""))]
+  "TARGET_64BIT"
   [(set (reg:DI 7) (plus:DI (reg:DI 7) (const_int -8)))
    (set (mem:SF (reg:DI 7)) (match_dup 1))])
 
@@ -2249,16 +2249,16 @@
 ;; %%% Kill this when call knows how to work this out.
 (define_split
   [(set (match_operand:DF 0 "push_operand" "")
-       (match_operand:DF 1 "register_operand" ""))]
-  "!TARGET_64BIT && reload_completed && ANY_FP_REGNO_P (REGNO (operands[1]))"
+       (match_operand:DF 1 "any_fp_register_operand" ""))]
+  "!TARGET_64BIT && reload_completed"
   [(set (reg:SI 7) (plus:SI (reg:SI 7) (const_int -8)))
    (set (mem:DF (reg:SI 7)) (match_dup 1))]
   "")
 
 (define_split
   [(set (match_operand:DF 0 "push_operand" "")
-       (match_operand:DF 1 "register_operand" ""))]
-  "TARGET_64BIT && reload_completed && ANY_FP_REGNO_P (REGNO (operands[1]))"
+       (match_operand:DF 1 "any_fp_register_operand" ""))]
+  "TARGET_64BIT && reload_completed"
   [(set (reg:DI 7) (plus:DI (reg:DI 7) (const_int -8)))
    (set (mem:DF (reg:DI 7)) (match_dup 1))]
   "")
@@ -2568,28 +2568,28 @@
    && (GET_MODE (operands[0]) == XFmode
        || GET_MODE (operands[0]) == TFmode
        || GET_MODE (operands[0]) == DFmode)
-   && (!REG_P (operands[1]) || !ANY_FP_REGNO_P (REGNO (operands[1])))"
+   && !ANY_FP_REG_P (operands[1])"
   [(const_int 0)]
   "ix86_split_long_move (operands); DONE;")
 
 (define_split
   [(set (match_operand:XF 0 "push_operand" "")
-       (match_operand:XF 1 "register_operand" ""))]
-  "!TARGET_64BIT && ANY_FP_REGNO_P (REGNO (operands[1]))"
+       (match_operand:XF 1 "any_fp_register_operand" ""))]
+  "!TARGET_64BIT"
   [(set (reg:SI 7) (plus:SI (reg:SI 7) (const_int -12)))
    (set (mem:XF (reg:SI 7)) (match_dup 1))])
 
 (define_split
   [(set (match_operand:TF 0 "push_operand" "")
-       (match_operand:TF 1 "register_operand" ""))]
-  "!TARGET_64BIT && ANY_FP_REGNO_P (REGNO (operands[1]))"
+       (match_operand:TF 1 "any_fp_register_operand" ""))]
+  "!TARGET_64BIT"
   [(set (reg:SI 7) (plus:SI (reg:SI 7) (const_int -16)))
    (set (mem:TF (reg:SI 7)) (match_dup 1))])
 
 (define_split
   [(set (match_operand:TF 0 "push_operand" "")
-       (match_operand:TF 1 "register_operand" ""))]
-  "TARGET_64BIT && ANY_FP_REGNO_P (REGNO (operands[1]))"
+       (match_operand:TF 1 "any_fp_register_operand" ""))]
+  "TARGET_64BIT"
   [(set (reg:DI 7) (plus:DI (reg:DI 7) (const_int -16)))
    (set (mem:TF (reg:DI 7)) (match_dup 1))])
 
@@ -3341,15 +3341,15 @@
 
 (define_split
   [(set (match_operand:DF 0 "push_operand" "")
-       (float_extend:DF (match_operand:SF 1 "register_operand" "")))]
-  "!TARGET_64BIT && FP_REGNO_P (REGNO (operands[1]))"
+       (float_extend:DF (match_operand:SF 1 "fp_register_operand" "")))]
+  "!TARGET_64BIT"
   [(set (reg:SI 7) (plus:SI (reg:SI 7) (const_int -8)))
    (set (mem:DF (reg:SI 7)) (float_extend:DF (match_dup 1)))])
 
 (define_split
   [(set (match_operand:DF 0 "push_operand" "")
-       (float_extend:DF (match_operand:SF 1 "register_operand" "")))]
-  "TARGET_64BIT && FP_REGNO_P (REGNO (operands[1]))"
+       (float_extend:DF (match_operand:SF 1 "fp_register_operand" "")))]
+  "TARGET_64BIT"
   [(set (reg:DI 7) (plus:DI (reg:DI 7) (const_int -8)))
    (set (mem:DF (reg:DI 7)) (float_extend:DF (match_dup 1)))])
 
@@ -3361,8 +3361,8 @@
 
 (define_split
   [(set (match_operand:XF 0 "push_operand" "")
-       (float_extend:XF (match_operand:SF 1 "register_operand" "")))]
-  "!TARGET_64BIT && FP_REGNO_P (REGNO (operands[1]))"
+       (float_extend:XF (match_operand:SF 1 "fp_register_operand" "")))]
+  "!TARGET_64BIT"
   [(set (reg:SI 7) (plus:SI (reg:SI 7) (const_int -12)))
    (set (mem:XF (reg:SI 7)) (float_extend:XF (match_dup 1)))])
 
@@ -3374,15 +3374,15 @@
 
 (define_split
   [(set (match_operand:TF 0 "push_operand" "")
-       (float_extend:TF (match_operand:SF 1 "register_operand" "")))]
-  "!TARGET_64BIT && FP_REGNO_P (REGNO (operands[1]))"
+       (float_extend:TF (match_operand:SF 1 "fp_register_operand" "")))]
+  "!TARGET_64BIT"
   [(set (reg:SI 7) (plus:SI (reg:SI 7) (const_int -16)))
    (set (mem:TF (reg:SI 7)) (float_extend:TF (match_dup 1)))])
 
 (define_split
   [(set (match_operand:TF 0 "push_operand" "")
-       (float_extend:TF (match_operand:SF 1 "register_operand" "")))]
-  "TARGET_64BIT && FP_REGNO_P (REGNO (operands[1]))"
+       (float_extend:TF (match_operand:SF 1 "fp_register_operand" "")))]
+  "TARGET_64BIT"
   [(set (reg:DI 7) (plus:DI (reg:DI 7) (const_int -16)))
    (set (mem:DF (reg:DI 7)) (float_extend:TF (match_dup 1)))])
 
@@ -3394,8 +3394,8 @@
 
 (define_split
   [(set (match_operand:XF 0 "push_operand" "")
-       (float_extend:XF (match_operand:DF 1 "register_operand" "")))]
-  "!TARGET_64BIT && FP_REGNO_P (REGNO (operands[1]))"
+       (float_extend:XF (match_operand:DF 1 "fp_register_operand" "")))]
+  "!TARGET_64BIT"
   [(set (reg:SI 7) (plus:SI (reg:SI 7) (const_int -12)))
    (set (mem:DF (reg:SI 7)) (float_extend:XF (match_dup 1)))])
 
@@ -3407,15 +3407,15 @@
 
 (define_split
   [(set (match_operand:TF 0 "push_operand" "")
-       (float_extend:TF (match_operand:DF 1 "register_operand" "")))]
-  "!TARGET_64BIT && FP_REGNO_P (REGNO (operands[1]))"
+       (float_extend:TF (match_operand:DF 1 "fp_register_operand" "")))]
+  "!TARGET_64BIT"
   [(set (reg:SI 7) (plus:SI (reg:SI 7) (const_int -16)))
    (set (mem:TF (reg:SI 7)) (float_extend:XF (match_dup 1)))])
 
 (define_split
   [(set (match_operand:TF 0 "push_operand" "")
-       (float_extend:TF (match_operand:DF 1 "register_operand" "")))]
-  "TARGET_64BIT && FP_REGNO_P (REGNO (operands[1]))"
+       (float_extend:TF (match_operand:DF 1 "fp_register_operand" "")))]
+  "TARGET_64BIT"
   [(set (reg:DI 7) (plus:DI (reg:DI 7) (const_int -16)))
    (set (mem:TF (reg:DI 7)) (float_extend:TF (match_dup 1)))])
 
@@ -3788,10 +3788,9 @@
 (define_split
   [(set (match_operand:SF 0 "register_operand" "")
        (float_truncate:SF
-        (match_operand:DF 1 "register_operand" "")))
+        (match_operand:DF 1 "fp_register_operand" "")))
    (clobber (match_operand:SF 2 "memory_operand" ""))]
-  "TARGET_80387 && reload_completed
-   && FP_REG_P (operands[1])"
+  "TARGET_80387 && reload_completed"
   [(set (match_dup 2) (float_truncate:SF (match_dup 1)))
    (set (match_dup 0) (match_dup 2))]
   "")
@@ -4670,10 +4669,9 @@
 
 ;; %%% Kill these when reload knows how to do it.
 (define_split
-  [(set (match_operand 0 "register_operand" "")
+  [(set (match_operand 0 "fp_register_operand" "")
        (float (match_operand 1 "register_operand" "")))]
-  "reload_completed && FLOAT_MODE_P (GET_MODE (operands[0]))
-   && FP_REG_P (operands[0])"
+  "reload_completed && FLOAT_MODE_P (GET_MODE (operands[0]))"
   [(const_int 0)]
 {
   operands[2] = ix86_force_to_memory (GET_MODE (operands[1]), operands[1]);
@@ -9348,19 +9346,19 @@
   "#")
 
 (define_split
-  [(set (match_operand:SF 0 "register_operand" "")
+  [(set (match_operand:SF 0 "fp_register_operand" "")
        (neg:SF (match_operand:SF 1 "register_operand" "")))
    (clobber (reg:CC 17))]
-  "TARGET_80387 && FP_REGNO_P (REGNO (operands[0])) && reload_completed"
+  "TARGET_80387 && reload_completed"
   [(set (match_dup 0)
        (neg:SF (match_dup 1)))]
   "")
 
 (define_split
-  [(set (match_operand:SF 0 "register_operand" "")
+  [(set (match_operand:SF 0 "register_and_not_fp_reg_operand" "")
        (neg:SF (match_operand:SF 1 "register_operand" "")))
    (clobber (reg:CC 17))]
-  "TARGET_80387 && reload_completed && !FP_REGNO_P (REGNO (operands[0]))"
+  "TARGET_80387 && reload_completed"
   [(parallel [(set (match_dup 0) (xor:SI (match_dup 0) (match_dup 1)))
              (clobber (reg:CC 17))])]
   "operands[1] = gen_int_mode (0x80000000, SImode);
@@ -9523,20 +9521,19 @@
   "#")
 
 (define_split
-  [(set (match_operand:DF 0 "register_operand" "")
+  [(set (match_operand:DF 0 "fp_register_operand" "")
        (neg:DF (match_operand:DF 1 "register_operand" "")))
    (clobber (reg:CC 17))]
-  "TARGET_80387 && FP_REGNO_P (REGNO (operands[0])) && reload_completed"
+  "TARGET_80387 && reload_completed"
   [(set (match_dup 0)
        (neg:DF (match_dup 1)))]
   "")
 
 (define_split
-  [(set (match_operand:DF 0 "register_operand" "")
+  [(set (match_operand:DF 0 "register_and_not_fp_reg_operand" "")
        (neg:DF (match_operand:DF 1 "register_operand" "")))
    (clobber (reg:CC 17))]
-  "!TARGET_64BIT && TARGET_80387 && reload_completed
-   && !FP_REGNO_P (REGNO (operands[0]))"
+  "!TARGET_64BIT && TARGET_80387 && reload_completed"
   [(parallel [(set (match_dup 3) (xor:SI (match_dup 3) (match_dup 4)))
              (clobber (reg:CC 17))])]
   "operands[4] = gen_int_mode (0x80000000, SImode);
@@ -9568,19 +9565,19 @@
   "#")
 
 (define_split
-  [(set (match_operand:XF 0 "register_operand" "")
+  [(set (match_operand:XF 0 "fp_register_operand" "")
        (neg:XF (match_operand:XF 1 "register_operand" "")))
    (clobber (reg:CC 17))]
-  "TARGET_80387 && FP_REGNO_P (REGNO (operands[0])) && reload_completed"
+  "TARGET_80387 && reload_completed"
   [(set (match_dup 0)
        (neg:XF (match_dup 1)))]
   "")
 
 (define_split
-  [(set (match_operand:XF 0 "register_operand" "")
+  [(set (match_operand:XF 0 "register_and_not_fp_reg_operand" "")
        (neg:XF (match_operand:XF 1 "register_operand" "")))
    (clobber (reg:CC 17))]
-  "TARGET_80387 && reload_completed && !FP_REGNO_P (REGNO (operands[0]))"
+  "TARGET_80387 && reload_completed"
   [(parallel [(set (match_dup 0) (xor:SI (match_dup 0) (match_dup 1)))
              (clobber (reg:CC 17))])]
   "operands[1] = GEN_INT (0x8000);
@@ -9598,19 +9595,19 @@
   "#")
 
 (define_split
-  [(set (match_operand:TF 0 "register_operand" "")
+  [(set (match_operand:TF 0 "fp_register_operand" "")
        (neg:TF (match_operand:TF 1 "register_operand" "")))
    (clobber (reg:CC 17))]
-  "TARGET_80387 && FP_REGNO_P (REGNO (operands[0])) && reload_completed"
+  "TARGET_80387 && reload_completed"
   [(set (match_dup 0)
        (neg:TF (match_dup 1)))]
   "")
 
 (define_split
-  [(set (match_operand:TF 0 "register_operand" "")
+  [(set (match_operand:TF 0 "register_and_not_fp_reg_operand" "")
        (neg:TF (match_operand:TF 1 "register_operand" "")))
    (clobber (reg:CC 17))]
-  "TARGET_80387 && reload_completed && !FP_REGNO_P (REGNO (operands[0]))"
+  "TARGET_80387 && reload_completed"
   [(parallel [(set (match_dup 0) (xor:SI (match_dup 0) (match_dup 1)))
              (clobber (reg:CC 17))])]
   "operands[1] = GEN_INT (0x8000);
@@ -9798,19 +9795,19 @@
   "#")
 
 (define_split
-  [(set (match_operand:SF 0 "register_operand" "")
+  [(set (match_operand:SF 0 "fp_register_operand" "")
        (abs:SF (match_operand:SF 1 "register_operand" "")))
    (clobber (reg:CC 17))]
-  "TARGET_80387 && FP_REGNO_P (REGNO (operands[0]))"
+  "TARGET_80387"
   [(set (match_dup 0)
        (abs:SF (match_dup 1)))]
   "")
 
 (define_split
-  [(set (match_operand:SF 0 "register_operand" "")
+  [(set (match_operand:SF 0 "register_and_not_fp_reg_operand" "")
        (abs:SF (match_operand:SF 1 "register_operand" "")))
    (clobber (reg:CC 17))]
-  "TARGET_80387 && reload_completed && !FP_REGNO_P (REGNO (operands[0]))"
+  "TARGET_80387 && reload_completed"
   [(parallel [(set (match_dup 0) (and:SI (match_dup 0) (match_dup 1)))
              (clobber (reg:CC 17))])]
   "operands[1] = gen_int_mode (~0x80000000, SImode);
@@ -9951,20 +9948,19 @@
   "#")
 
 (define_split
-  [(set (match_operand:DF 0 "register_operand" "")
+  [(set (match_operand:DF 0 "fp_register_operand" "")
        (abs:DF (match_operand:DF 1 "register_operand" "")))
    (clobber (reg:CC 17))]
-  "TARGET_80387 && FP_REGNO_P (REGNO (operands[0])) && reload_completed"
+  "TARGET_80387 && reload_completed"
   [(set (match_dup 0)
        (abs:DF (match_dup 1)))]
   "")
 
 (define_split
-  [(set (match_operand:DF 0 "register_operand" "")
+  [(set (match_operand:DF 0 "register_and_not_fp_reg_operand" "")
        (abs:DF (match_operand:DF 1 "register_operand" "")))
    (clobber (reg:CC 17))]
-  "!TARGET_64BIT && TARGET_80387 && reload_completed &&
-   !FP_REGNO_P (REGNO (operands[0]))"
+  "!TARGET_64BIT && TARGET_80387 && reload_completed"
   [(parallel [(set (match_dup 3) (and:SI (match_dup 3) (match_dup 4)))
              (clobber (reg:CC 17))])]
   "operands[4] = gen_int_mode (~0x80000000, SImode);
@@ -9996,19 +9992,19 @@
   "#")
 
 (define_split
-  [(set (match_operand:XF 0 "register_operand" "")
+  [(set (match_operand:XF 0 "fp_register_operand" "")
        (abs:XF (match_operand:XF 1 "register_operand" "")))
    (clobber (reg:CC 17))]
-  "TARGET_80387 && FP_REGNO_P (REGNO (operands[0])) && reload_completed"
+  "TARGET_80387 && reload_completed"
   [(set (match_dup 0)
        (abs:XF (match_dup 1)))]
   "")
 
 (define_split
-  [(set (match_operand:XF 0 "register_operand" "")
+  [(set (match_operand:XF 0 "register_and_not_fp_reg_operand" "")
        (abs:XF (match_operand:XF 1 "register_operand" "")))
    (clobber (reg:CC 17))]
-  "TARGET_80387 && reload_completed && !FP_REGNO_P (REGNO (operands[0]))"
+  "TARGET_80387 && reload_completed"
   [(parallel [(set (match_dup 0) (and:SI (match_dup 0) (match_dup 1)))
              (clobber (reg:CC 17))])]
   "operands[1] = GEN_INT (~0x8000);
@@ -10023,19 +10019,19 @@
   "#")
 
 (define_split
-  [(set (match_operand:TF 0 "register_operand" "")
+  [(set (match_operand:TF 0 "fp_register_operand" "")
        (abs:TF (match_operand:TF 1 "register_operand" "")))
    (clobber (reg:CC 17))]
-  "TARGET_80387 && FP_REGNO_P (REGNO (operands[0])) && reload_completed"
+  "TARGET_80387 && reload_completed"
   [(set (match_dup 0)
        (abs:TF (match_dup 1)))]
   "")
 
 (define_split
-  [(set (match_operand:TF 0 "register_operand" "")
+  [(set (match_operand:TF 0 "register_and_not_any_fp_reg_operand" "")
        (abs:TF (match_operand:TF 1 "register_operand" "")))
    (clobber (reg:CC 17))]
-  "TARGET_80387 && reload_completed && !FP_REGNO_P (REGNO (operands[0]))"
+  "TARGET_80387 && reload_completed"
   [(parallel [(set (match_dup 0) (and:SI (match_dup 0) (match_dup 1)))
              (clobber (reg:CC 17))])]
   "operands[1] = GEN_INT (~0x8000);
@@ -15983,12 +15979,12 @@
    (set_attr "mode" "DF")])
 
 (define_split
-  [(set (match_operand:DF 0 "register_operand" "")
+  [(set (match_operand:DF 0 "register_and_not_any_fp_reg_operand" "")
        (if_then_else:DF (match_operator 1 "fcmov_comparison_operator" 
                                [(match_operand 4 "" "") (const_int 0)])
                      (match_operand:DF 2 "nonimmediate_operand" "")
                      (match_operand:DF 3 "nonimmediate_operand" "")))]
-  "!TARGET_64BIT && !ANY_FP_REG_P (operands[0]) && reload_completed"
+  "!TARGET_64BIT && reload_completed"
   [(set (match_dup 2)
        (if_then_else:SI (match_op_dup 1 [(match_dup 4) (const_int 0)])
                      (match_dup 5)
@@ -16096,13 +16092,13 @@
 ;; We can't represent the LT test directly.  Do this by swapping the operands.
 
 (define_split
-  [(set (match_operand:SF 0 "register_operand" "")
+  [(set (match_operand:SF 0 "fp_register_operand" "")
        (if_then_else:SF (lt (match_operand:SF 1 "register_operand" "")
                             (match_operand:SF 2 "register_operand" ""))
                         (match_operand:SF 3 "register_operand" "")
                         (match_operand:SF 4 "register_operand" "")))
    (clobber (reg:CC 17))]
-  "FP_REG_P (operands[0]) && reload_completed
+  "reload_completed
    && ((operands_match_p (operands[1], operands[3])
        && operands_match_p (operands[2], operands[4]))
        || (operands_match_p (operands[1], operands[4])
@@ -16178,13 +16174,13 @@
 
 ;; We can't represent the LT test directly.  Do this by swapping the operands.
 (define_split
-  [(set (match_operand:DF 0 "register_operand" "")
+  [(set (match_operand:DF 0 "fp_register_operand" "")
        (if_then_else:DF (lt (match_operand:DF 1 "register_operand" "")
                             (match_operand:DF 2 "register_operand" ""))
                         (match_operand:DF 3 "register_operand" "")
                         (match_operand:DF 4 "register_operand" "")))
    (clobber (reg:CC 17))]
-  "FP_REG_P (operands[0]) && reload_completed
+  "reload_completed
    && ((operands_match_p (operands[1], operands[3])
        && operands_match_p (operands[2], operands[4]))
        || (operands_match_p (operands[1], operands[4])
@@ -16259,13 +16255,13 @@
                         (match_dup 2)))])
 
 (define_split
-  [(set (match_operand:SF 0 "register_operand" "")
+  [(set (match_operand:SF 0 "fp_register_operand" "")
        (if_then_else:SF (gt (match_operand:SF 1 "register_operand" "")
                             (match_operand:SF 2 "register_operand" ""))
                         (match_operand:SF 3 "register_operand" "")
                         (match_operand:SF 4 "register_operand" "")))
    (clobber (reg:CC 17))]
-  "FP_REG_P (operands[0]) && reload_completed
+  "reload_completed
    && ((operands_match_p (operands[1], operands[3])
        && operands_match_p (operands[2], operands[4]))
        || (operands_match_p (operands[1], operands[4])
@@ -16340,13 +16336,13 @@
                         (match_dup 2)))])
 
 (define_split
-  [(set (match_operand:DF 0 "register_operand" "")
+  [(set (match_operand:DF 0 "fp_register_operand" "")
        (if_then_else:DF (gt (match_operand:DF 1 "register_operand" "")
                             (match_operand:DF 2 "register_operand" ""))
                         (match_operand:DF 3 "register_operand" "")
                         (match_operand:DF 4 "register_operand" "")))
    (clobber (reg:CC 17))]
-  "FP_REG_P (operands[0]) && reload_completed
+  "reload_completed
    && ((operands_match_p (operands[1], operands[3])
        && operands_match_p (operands[2], operands[4]))
        || (operands_match_p (operands[1], operands[4])
About OSDN
Find Software
Develop Software
Help