ia64.md (movsi and movdi patterns): Allow moves from 8-bit constants to AR registers.
authorRichard Henderson <rth@cygnus.com>
Tue, 5 Sep 2000 23:20:24 +0000 (16:20 -0700)
committerRichard Henderson <rth@gcc.gnu.org>
Tue, 5 Sep 2000 23:20:24 +0000 (16:20 -0700)
        * config/ia64.md (movsi and movdi patterns): Allow moves from
        8-bit constants to AR registers.

From-SVN: r36172

gcc/ChangeLog
gcc/config/ia64/ia64.md

index c63e7f8a15729f24c57a72ba2ec86641a823ab99..07382659190ba4b89190606adc7c064e64c4155a 100644 (file)
@@ -1,3 +1,8 @@
+2000-09-05  Richard Henderson  <rth@cygnus.com>
+
+       * config/ia64.md (movsi and movdi patterns): Allow moves from
+       8-bit constants to AR registers.
+
 2000-09-05  Richard Henderson  <rth@cygnus.com>
 
        * config/ia64/ia64.md (mulhi3): New.
index a84b1856caf9b50a40b31f6dfae104f3e4ef24ba..68fbbefec44f5dbadf2c0056c8174b2b7c424c7a 100644 (file)
        [(match_operand:CC 3 "register_operand" "c,c,c,c,c,c,c,c")
         (const_int 0)])
      (set (match_operand:SI 0 "register_operand"  "=r,r,r, r,*f,*f, r,*d")
-         (match_operand:SI 1 "nonmemory_operand" "rO,J,i,*f,rO,*f,*d,rO")))]
+         (match_operand:SI 1 "nonmemory_operand" "rO,J,i,*f,rO,*f,*d,rK")))]
   "TARGET_A_STEP && ia64_move_ok (operands[0], operands[1])"
   "@
    (%J2) mov %0 = %r1
 
 (define_insn "*movsi_internal_astep"
   [(set (match_operand:SI 0 "destination_operand" "=r,r,r,r, m, r,*f,*f, r,*d")
-       (match_operand:SI 1 "move_operand"        "rO,J,i,m,rO,*f,rO,*f,*d,rO"))]
+       (match_operand:SI 1 "move_operand"        "rO,J,i,m,rO,*f,rO,*f,*d,rK"))]
   "TARGET_A_STEP && ia64_move_ok (operands[0], operands[1])"
   "@
   mov %0 = %r1
 
 (define_insn "*movsi_internal"
   [(set (match_operand:SI 0 "destination_operand" "=r,r,r,r, m, r,*f,*f, r,*d")
-       (match_operand:SI 1 "move_operand"        "rO,J,i,m,rO,*f,rO,*f,*d,rO"))]
+       (match_operand:SI 1 "move_operand"        "rO,J,i,m,rO,*f,rO,*f,*d,rK"))]
   "! TARGET_A_STEP && ia64_move_ok (operands[0], operands[1])"
   "@
   mov %0 = %r1
 (define_insn ""
   [(cond_exec
      (match_operator 2 "predicate_operator"
-       [(match_operand:CC 3 "register_operand" "c,c,c,c,c,c,c,c,c,c")
+       [(match_operand:CC 3 "register_operand" "c,c,c,c,c,c,c,c,c,c,c")
         (const_int 0)])
      (set (match_operand:DI 0 "register_operand"
-                             "=r,r,r, r,*f,*f,   r,*b*e, r,*d")
+                             "=r,r,r, r,*f,*f,   r,*b,*e, r,*d")
          (match_operand:DI 1 "nonmemory_operand"
-                             "rO,J,i,*f,rO,*f,*b*e,  rO,*d,rO")))]
+                             "rO,J,i,*f,rO,*f,*b*e,rO,rK,*d,rK")))]
   "TARGET_A_STEP && ia64_move_ok (operands[0], operands[1])"
   "*
 {
     \"(%J2) mov %0 = %1\",
     \"(%J2) mov %0 = %r1\",
     \"(%J2) mov %0 = %1\",
-    \"(%J2) mov %0 = %r1\"
+    \"(%J2) mov %0 = %1\",
+    \"(%J2) mov %0 = %1\"
   };
 
   /* We use 'i' for alternative 2 despite possible PIC problems.
 
   return alt[which_alternative];
 }"
-  [(set_attr "type" "A,A,L,M,M,F,I,I,M,M")
+  [(set_attr "type" "A,A,L,M,M,F,I,I,I,M,M")
    (set_attr "predicable" "no")])
 
 ;; This is used during early compilation to delay the decision on
 
 (define_insn "*movdi_internal_astep"
   [(set (match_operand:DI 0 "destination_operand"
-                   "=r,r,r,r, m, r,*f,*f,*f, Q,   r,*b*e, r,*d, r,*c")
+                   "=r,r,r,r, m, r,*f,*f,*f, Q,   r,*b,*e, r,*d, r,*c")
        (match_operand:DI 1 "move_operand"
-                   "rO,J,i,m,rO,*f,rO,*f, Q,*f,*b*e,  rO,*d,rO,*c,rO"))]
+                   "rO,J,i,m,rO,*f,rO,*f, Q,*f,*b*e,rO,rK,*d,rK,*c,rO"))]
   "TARGET_A_STEP && ia64_move_ok (operands[0], operands[1])"
   "*
 {
     \"mov %0 = %1\",
     \"mov %0 = %r1\",
     \"mov %0 = %1\",
-    \"mov %0 = %r1\",
+    \"mov %0 = %1\",
+    \"mov %0 = %1\",
     \"mov %0 = pr\",
     \"mov pr = %1, -1\"
   };
 
   return alt[which_alternative];
 }"
-  [(set_attr "type" "A,A,L,M,M,M,M,F,M,M,I,I,M,M,I,I")
+  [(set_attr "type" "A,A,L,M,M,M,M,F,M,M,I,I,I,M,M,I,I")
    (set_attr "predicable" "no")])
 
 (define_insn "*movdi_internal"
   [(set (match_operand:DI 0 "destination_operand"
-                   "=r,r,r,r, m, r,*f,*f,*f, Q,   r,*b*e, r,*d, r,*c")
+                   "=r,r,r,r, m, r,*f,*f,*f, Q,   r,*b,*e, r,*d, r,*c")
        (match_operand:DI 1 "move_operand"
-                   "rO,J,i,m,rO,*f,rO,*f, Q,*f,*b*e,  rO,*d,rO,*c,rO"))]
+                   "rO,J,i,m,rO,*f,rO,*f, Q,*f,*b*e,rO,rK,*d,rK,*c,rO"))]
   "! TARGET_A_STEP && ia64_move_ok (operands[0], operands[1])"
   "*
 {
     \"%,mov %0 = %1\",
     \"%,mov %0 = %r1\",
     \"%,mov %0 = %1\",
-    \"%,mov %0 = %r1\",
+    \"%,mov %0 = %1\",
+    \"%,mov %0 = %1\",
     \"mov %0 = pr\",
     \"mov pr = %1, -1\"
   };
 
   return alt[which_alternative];
 }"
-  [(set_attr "type" "A,A,L,M,M,M,M,F,M,M,I,I,M,M,I,I")])
+  [(set_attr "type" "A,A,L,M,M,M,M,F,M,M,I,I,I,M,M,I,I")])
 
 (define_split
   [(set (match_operand:DI 0 "register_operand" "")
 
 (define_insn "*cmovdi_internal"
   [(set (match_operand:DI 0 "nonimmediate_operand"
-               "=r,m,*f,Q,*b*d*e,r,m,*f,Q,*b*d*e,r,m,*f,Q,*b*d*e")
+               "=r,m,*f,Q,*b,*d*e,r,m,*f,Q,*b,*d*e,r,m,*f,Q,*b,*d*e")
        (if_then_else:DI
          (match_operator:CC 4 "predicate_operator"
            [(match_operand:CC 1 "register_operand"
-                              "c,c,c,c,c,c,c,c,c,c,c,c,c,c,c")
+                              "c,c,c,c,c,c,c,c,c,c,c,c,c,c,c,c,c,c")
             (const_int 0)])
          (match_operand:DI 2 "general_operand"
-               "0,0,0,0,0,rim*f*b*d*e,rO,rOQ,*f,r,rim*f*b*d*e,rO,rOQ,*f,r")
+               "0,0,0,0,0,0,rim*f*b*d*e,rO,rOQ,*f,rO,rK,rim*f*b*d*e,rO,rOQ,*f,rO,rK")
          (match_operand:DI 3 "general_operand"
-               "rim*f*b*d*e,rO,rOQ,*f,r,0,0,0,0,0,rim*f*b*d*e,rO,rOQ,*f,r")))]
+               "rim*f*b*d*e,rO,rOQ,*f,rO,rK,0,0,0,0,0,0,rim*f*b*d*e,rO,rOQ,*f,rO,rK")))]
   "! TARGET_A_STEP"
   "* abort ();"
   [(set_attr "predicable" "no")])