diff mbox

[i386] : Use explicit mode macros on wide-insn splitters

Message ID CAFULd4ZHqRd03hEt4ve9YoqCMXc6Uk5pmNjMBejFyJM74d_oBw@mail.gmail.com
State New
Headers show

Commit Message

Uros Bizjak Nov. 24, 2016, 9:50 p.m. UTC 
2016-11-24  Uros Bizjak  <ubizjak@gmail.com>

    * config/i386/i386.md (wide AND insn to QImode splitter): Use
    explicit mode macros.
    (wide OR insn to QImode splitter): Ditto.

Bootstrapped and regression tested on x86_64-linux-gnu {,-m32}.

Committed to mainline SVN.

Uros.
diff mbox

Patch

Index: i386.md
===================================================================
--- i386.md	(revision 242850)
+++ i386.md	(working copy)
@@ -8625,14 +8625,13 @@ 
 ;; of memory mismatch stalls.  We may want to do the splitting for optimizing
 ;; for size, but that can (should?) be handled by generic code instead.
 (define_split
-  [(set (match_operand 0 "QIreg_operand")
-	(and (match_operand 1 "register_operand")
-	     (match_operand 2 "const_int_operand")))
+  [(set (match_operand:SWI248 0 "QIreg_operand")
+	(and:SWI248 (match_operand:SWI248 1 "register_operand")
+		    (match_operand:SWI248 2 "const_int_operand")))
    (clobber (reg:CC FLAGS_REG))]
    "reload_completed
     && (!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun))
-    && !(~INTVAL (operands[2]) & ~(255 << 8))
-    && GET_MODE (operands[0]) != QImode"
+    && !(~INTVAL (operands[2]) & ~(255 << 8))"
   [(parallel [(set (zero_extract:SI (match_dup 0) (const_int 8) (const_int 8))
 		   (and:SI (zero_extract:SI (match_dup 1)
 					    (const_int 8) (const_int 8))
@@ -8647,15 +8646,14 @@ 
 ;; Since AND can be encoded with sign extended immediate, this is only
 ;; profitable when 7th bit is not set.
 (define_split
-  [(set (match_operand 0 "any_QIreg_operand")
-	(and (match_operand 1 "general_operand")
-	     (match_operand 2 "const_int_operand")))
+  [(set (match_operand:SWI248 0 "any_QIreg_operand")
+	(and:SWI248 (match_operand:SWI248 1 "general_operand")
+		    (match_operand:SWI248 2 "const_int_operand")))
    (clobber (reg:CC FLAGS_REG))]
    "reload_completed
     && (!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun))
     && !(~INTVAL (operands[2]) & ~255)
-    && !(INTVAL (operands[2]) & 128)
-    && GET_MODE (operands[0]) != QImode"
+    && !(INTVAL (operands[2]) & 128)"
   [(parallel [(set (strict_low_part (match_dup 0))
 		   (and:QI (match_dup 1)
 			   (match_dup 2)))
@@ -9020,15 +9018,19 @@ 
    (set_attr "length_immediate" "0")
    (set_attr "mode" "QI")])
 
+;; Convert wide OR instructions with immediate operand to shorter QImode
+;; equivalents when possible.
+;; Don't do the splitting with memory operands, since it introduces risk
+;; of memory mismatch stalls.  We may want to do the splitting for optimizing
+;; for size, but that can (should?) be handled by generic code instead.
 (define_split
-  [(set (match_operand 0 "QIreg_operand")
-	(any_or (match_operand 1 "register_operand")
-		(match_operand 2 "const_int_operand")))
+  [(set (match_operand:SWI248 0 "QIreg_operand")
+	(any_or:SWI248 (match_operand:SWI248 1 "register_operand")
+		       (match_operand:SWI248 2 "const_int_operand")))
    (clobber (reg:CC FLAGS_REG))]
    "reload_completed
     && (!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun))
-    && !(INTVAL (operands[2]) & ~(255 << 8))
-    && GET_MODE (operands[0]) != QImode"
+    && !(INTVAL (operands[2]) & ~(255 << 8))"
   [(parallel [(set (zero_extract:SI (match_dup 0) (const_int 8) (const_int 8))
 		   (any_or:SI (zero_extract:SI (match_dup 1)
 					       (const_int 8) (const_int 8))
@@ -9043,15 +9045,14 @@ 
 ;; Since OR can be encoded with sign extended immediate, this is only
 ;; profitable when 7th bit is set.
 (define_split
-  [(set (match_operand 0 "any_QIreg_operand")
-	(any_or (match_operand 1 "general_operand")
-		(match_operand 2 "const_int_operand")))
+  [(set (match_operand:SWI248 0 "any_QIreg_operand")
+	(any_or:SWI248 (match_operand:SWI248 1 "general_operand")
+		       (match_operand:SWI248 2 "const_int_operand")))
    (clobber (reg:CC FLAGS_REG))]
    "reload_completed
     && (!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun))
     && !(INTVAL (operands[2]) & ~255)
-    && (INTVAL (operands[2]) & 128)
-    && GET_MODE (operands[0]) != QImode"
+    && (INTVAL (operands[2]) & 128)"
   [(parallel [(set (strict_low_part (match_dup 0))
 		   (any_or:QI (match_dup 1)
 			      (match_dup 2)))