[patch, testsuite] Fix vectorizer testcases

[patch, testsuite] Fix vectorizer testcases

[Ira Rosen]

[-- Attachment #1: Type: text/plain, Size: 1439 bytes --]


Fix vectorizer testcases mainly to pass on SPU and 750cl.

Tested on SPU and PowerPC.
O.K. for mainline?

Thanks,
Revital and Ira

ChangeLog entry:

      * gcc.dg/vect/vect-ifcvt-5.c: Require vect_int.
      * gcc.dg/vect/pr33369.c: Likewise.
      * gcc.dg/vect/slp-33.c: Add spaces.
      * gcc.dg/vect/no-scevccp-outer-18.c: Target vect_interleave.
      * gcc.dg/vect/vect-ifcvt-6.c: Require vect_int.
      * gcc.dg/vect/no-scevccp-outer-19.c: Xfail on vect_no_shortint_cvt.
      * gcc.dg/vect/vect-ifcvt-7.c: Require vect_int.
      * gcc.dg/vect/vect-strided-store-u16-i4.c: Target
!vect_no_shortint_cvt.
      * gcc.dg/vect/slp-10.c: Add spaces.
      * gcc.dg/vect/no-scevccp-outer-21.c: Xfail on vect_no_intshort_cvt.
      * gcc.dg/vect/slp-36.c: Require vect_int.
      * gcc.dg/vect/vect-strided-store-u32-i2.c,
gcc.dg/vect/vect-ifcvt-2.c,
      gcc.dg/vect/vect-ifcvt-3.c, gcc.dg/vect/vect-82.c,
      gcc.dg/vect/vect-83.c: Likewise.
      * gcc.dg/vect/no-scevccp-outer-16.c: Xfail on vect_no_shortint_cvt.
      * gcc.dg/vect/no-scevccp-outer-17.c: Likewise.
      * lib/target-supports.exp (vect_no_intshort_cvt): New.
      (vect_no_shortint_cvt): New.
      (vect_aligned_arrays): Depend on natural_alignment_32.
      (natural_alignment): Split into...
      (natural_alignment_32, natural_alignment_64): New.
      (alignment_reachable_for_double): Depend on natural_alignment_64.

(See attached file: tests.txt)


[-- Attachment #2: tests.txt --]
[-- Type: text/plain, Size: 14850 bytes --]

Index: gcc.dg/vect/vect-ifcvt-5.c
===================================================================
--- gcc.dg/vect/vect-ifcvt-5.c	(revision 128708)
+++ gcc.dg/vect/vect-ifcvt-5.c	(working copy)
@@ -1,4 +1,5 @@
 /* { dg-require-effective-target vect_condition } */
+/* { dg-require-effective-target vect_int } */
 
 #include <stdarg.h>
 #include <signal.h>
Index: gcc.dg/vect/pr33369.c
===================================================================
--- gcc.dg/vect/pr33369.c	(revision 128708)
+++ gcc.dg/vect/pr33369.c	(working copy)
@@ -1,4 +1,5 @@
 /* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
 /* { dg-require-effective-target vect_shift } */
 
 typedef struct tagPOINT
Index: gcc.dg/vect/slp-33.c
===================================================================
--- gcc.dg/vect/slp-33.c	(revision 128708)
+++ gcc.dg/vect/slp-33.c	(working copy)
@@ -104,9 +104,9 @@
 
 /* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect"  {target {vect_intfloat_cvt && vect_int_mult} } } } */
 /* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect"  {target {{! { vect_intfloat_cvt}} && vect_int_mult} } } } */
-/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect"  {target {{! { vect_intfloat_cvt}} && {!{vect_int_mult}}} } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect"  {target {{! { vect_intfloat_cvt}} && {! {vect_int_mult}}} } } } */
 /* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect" {target {vect_intfloat_cvt && vect_int_mult} } } } */
 /* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect"  {target {{! { vect_intfloat_cvt}} && vect_int_mult} } } } */
-/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect"  {target {{! { vect_intfloat_cvt}} && {!{vect_int_mult}}} } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect"  {target {{! { vect_intfloat_cvt}} && {! {vect_int_mult}}} } } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
   
Index: gcc.dg/vect/no-scevccp-outer-18.c
===================================================================
--- gcc.dg/vect/no-scevccp-outer-18.c	(revision 128708)
+++ gcc.dg/vect/no-scevccp-outer-18.c	(working copy)
@@ -47,5 +47,5 @@
   return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { target vect_interleave } } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
Index: gcc.dg/vect/vect-ifcvt-6.c
===================================================================
--- gcc.dg/vect/vect-ifcvt-6.c	(revision 128708)
+++ gcc.dg/vect/vect-ifcvt-6.c	(working copy)
@@ -1,4 +1,5 @@
 /* { dg-require-effective-target vect_condition } */
+/* { dg-require-effective-target vect_int } */
 
 #include <stdarg.h>
 #include <signal.h>
Index: gcc.dg/vect/no-scevccp-outer-19.c
===================================================================
--- gcc.dg/vect/no-scevccp-outer-19.c	(revision 128708)
+++ gcc.dg/vect/no-scevccp-outer-19.c	(working copy)
@@ -48,5 +48,5 @@
   return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { xfail vect_no_shortint_cvt } } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
Index: gcc.dg/vect/vect-ifcvt-7.c
===================================================================
--- gcc.dg/vect/vect-ifcvt-7.c	(revision 128708)
+++ gcc.dg/vect/vect-ifcvt-7.c	(working copy)
@@ -1,4 +1,5 @@
 /* { dg-require-effective-target vect_condition } */
+/* { dg-require-effective-target vect_int } */
 
 #include <stdarg.h>
 #include <signal.h>
Index: gcc.dg/vect/vect-strided-store-u16-i4.c
===================================================================
--- gcc.dg/vect/vect-strided-store-u16-i4.c	(revision 128708)
+++ gcc.dg/vect/vect-strided-store-u16-i4.c	(working copy)
@@ -65,8 +65,8 @@
   return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect"  { target { vect_interleave } } } } */
-/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { ! { vect_interleave } } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect"  { target { { vect_interleave } && { ! { vect_no_intshort_cvt } } } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { { ! { vect_interleave } } && { ! { vect_no_intshort_cvt } }  } } } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
 
 
Index: gcc.dg/vect/slp-10.c
===================================================================
--- gcc.dg/vect/slp-10.c	(revision 128708)
+++ gcc.dg/vect/slp-10.c	(working copy)
@@ -106,9 +106,9 @@
 
 /* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect"  {target {vect_intfloat_cvt && vect_int_mult} } } } */
 /* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect"  {target {{! { vect_intfloat_cvt}} && vect_int_mult} } } } */
-/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect"  {target {{! { vect_intfloat_cvt}} && {!{vect_int_mult}}} } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect"  {target {{! { vect_intfloat_cvt}} && { ! {vect_int_mult}}} } } } */
 /* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect" {target {vect_intfloat_cvt && vect_int_mult} } } } */
 /* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect"  {target {{! { vect_intfloat_cvt}} && vect_int_mult} } } } */
-/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect"  {target {{! { vect_intfloat_cvt}} && {!{vect_int_mult}}} } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect"  {target {{! { vect_intfloat_cvt}} && { ! {vect_int_mult}}} } } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
   
Index: gcc.dg/vect/no-scevccp-outer-21.c
===================================================================
--- gcc.dg/vect/no-scevccp-outer-21.c	(revision 128708)
+++ gcc.dg/vect/no-scevccp-outer-21.c	(working copy)
@@ -58,5 +58,5 @@
   return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { xfail vect_no_intshort_cvt } } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
Index: gcc.dg/vect/slp-36.c
===================================================================
--- gcc.dg/vect/slp-36.c	(revision 128708)
+++ gcc.dg/vect/slp-36.c	(working copy)
@@ -1,4 +1,5 @@
 /* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
 /* { dg-require-effective-target vect_shift } */
 
 #define N 32
Index: gcc.dg/vect/vect-strided-store-u32-i2.c
===================================================================
--- gcc.dg/vect/vect-strided-store-u32-i2.c	(revision 128708)
+++ gcc.dg/vect/vect-strided-store-u32-i2.c	(working copy)
@@ -1,4 +1,4 @@
-/* { dg-require-effective-target vect_float } */
+/* { dg-require-effective-target vect_int } */
 
 #include <stdarg.h>
 #include <stdio.h>
Index: gcc.dg/vect/vect-ifcvt-2.c
===================================================================
--- gcc.dg/vect/vect-ifcvt-2.c	(revision 128708)
+++ gcc.dg/vect/vect-ifcvt-2.c	(working copy)
@@ -1,4 +1,5 @@
 /* { dg-require-effective-target vect_condition } */
+/* { dg-require-effective-target vect_int } */
 
 #include <stdarg.h>
 #include <signal.h>
Index: gcc.dg/vect/vect-ifcvt-3.c
===================================================================
--- gcc.dg/vect/vect-ifcvt-3.c	(revision 128708)
+++ gcc.dg/vect/vect-ifcvt-3.c	(working copy)
@@ -1,4 +1,5 @@
 /* { dg-require-effective-target vect_condition } */
+/* { dg-require-effective-target vect_int } */
 
 #include <stdarg.h>
 #include <signal.h>
Index: gcc.dg/vect/no-scevccp-outer-16.c
===================================================================
--- gcc.dg/vect/no-scevccp-outer-16.c	(revision 128708)
+++ gcc.dg/vect/no-scevccp-outer-16.c	(working copy)
@@ -58,5 +58,5 @@
   return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { xfail vect_no_shortint_cvt } } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
Index: gcc.dg/vect/vect-82.c
===================================================================
--- gcc.dg/vect/vect-82.c	(revision 128708)
+++ gcc.dg/vect/vect-82.c	(working copy)
@@ -1,4 +1,5 @@
 /* { dg-do run { target powerpc*-*-* } } */
+/* { dg-require-effective-target vect_int } */
 
 #include <stdarg.h>
 #include "tree-vect.h"
Index: gcc.dg/vect/no-scevccp-outer-17.c
===================================================================
--- gcc.dg/vect/no-scevccp-outer-17.c	(revision 128708)
+++ gcc.dg/vect/no-scevccp-outer-17.c	(working copy)
@@ -64,5 +64,5 @@
   return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { xfail vect_no_shortint_cvt } } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
Index: gcc.dg/vect/vect-83.c
===================================================================
--- gcc.dg/vect/vect-83.c	(revision 128708)
+++ gcc.dg/vect/vect-83.c	(working copy)
@@ -1,4 +1,5 @@
 /* { dg-do run { target powerpc*-*-* } } */
+/* { dg-require-effective-target vect_int } */
 
 #include <stdarg.h>
 #include "tree-vect.h"
Index: lib/target-supports.exp
===================================================================
--- lib/target-supports.exp	(revision 128708)
+++ lib/target-supports.exp	(working copy)
@@ -1499,7 +1499,45 @@
     return $et_vect_floatint_cvt_saved
 }
 
+# Return 1 if the target doesn't support int->short conversion
+#
 
+proc check_effective_target_vect_no_intshort_cvt { } {
+    global et_vect_no_intshort_cvt_saved
+
+    if [info exists et_vect_no_intshort_cvt_saved] {
+        verbose "check_effective_target_vect_no_intshort_cvt: using cached result" 2
+    } else {
+        set et_vect_no_intshort_cvt_saved 0
+        if { [istarget spu-*-*] } {
+           set et_vect_no_intshort_cvt_saved 1
+        }
+    }
+
+    verbose "check_effective_target_vect_no_intshort_cvt: returning $et_vect_no_intshort_cvt_saved" 2
+    return $et_vect_no_intshort_cvt_saved
+}
+
+
+# Return 1 if the target doesn't support short->int conversion
+#
+
+proc check_effective_target_vect_no_shortint_cvt { } {
+    global et_vect_no_shortint_cvt_saved
+
+    if [info exists et_vect_no_shortint_cvt_saved] {
+        verbose "check_effective_target_vect_no_shortint_cvt: using cached result" 2
+    } else {
+        set et_vect_no_shortint_cvt_saved 0
+        if { [istarget spu-*-*] } {
+           set et_vect_no_shortint_cvt_saved 1
+        }
+    }
+
+    verbose "check_effective_target_vect_no_shortint_cvt: returning $et_vect_no_shortint_cvt_saved" 2
+    return $et_vect_no_shortint_cvt_saved
+}
+
 # Return 1 is this is an arm target using 32-bit instructions
 proc check_effective_target_arm32 { } {
     return [check_no_compiler_messages arm32 assembly {
@@ -2135,7 +2173,7 @@
     } else {
 	set et_vect_aligned_arrays_saved 0
 	if { ([istarget x86_64-*-*]
-	      || [istarget i?86-*-*]) && [is-effective-target lp64] } {
+	      || [istarget i?86-*-*]) && [is-effective-target lp64] } { 
 	    set et_vect_aligned_arrays_saved 1
 	}
     }
@@ -2143,27 +2181,49 @@
     return $et_vect_aligned_arrays_saved
 }
 
-# Return 1 if types are naturally aligned (aligned to their type-size),
-# 0 otherwise.
+# Return 1 if types (32 bit and less types) are naturally aligned 
+# (aligned to their type-size), 0 otherwise.
 #
 # This won't change for different subtargets so cache the result.
 
-proc check_effective_target_natural_alignment { } {
-    global et_natural_alignment
+proc check_effective_target_natural_alignment_32 { } {
+    global et_natural_alignment_32
 
-    if [info exists et_natural_alignment_saved] {
-        verbose "check_effective_target_natural_alignment: using cached result" 2
+    if [info exists et_natural_alignment_32_saved] {
+        verbose "check_effective_target_natural_alignment_32: using cached result" 2
     } else {
 	# FIXME: 32bit powerpc: guaranteed only if MASK_ALIGN_NATURAL/POWER.
-        set et_natural_alignment_saved 1
+        set et_natural_alignment_32_saved 1
         if { ([istarget *-*-darwin*] && [is-effective-target lp64]) } { 
-            set et_natural_alignment_saved 0
+            set et_natural_alignment_32_saved 0
         }
     }
-    verbose "check_effective_target_natural_alignment: returning $et_natural_alignment_saved" 2
-    return $et_natural_alignment_saved
+    verbose "check_effective_target_natural_alignment_32: returning $et_natural_alignment_32_saved" 2
+    return $et_natural_alignment_32_saved
 }
 
+# Return 1 if types (64 bit and less) are naturally aligned (aligned to their 
+# type-size), 0 otherwise.
+#
+# This won't change for different subtargets so cache the result.
+
+proc check_effective_target_natural_alignment_64 { } {
+    global et_natural_alignment_64
+
+    if [info exists et_natural_alignment_64_saved] {
+        verbose "check_effective_target_natural_alignment_64: using cached result" 2
+    } else {
+        set et_natural_alignment_64_saved 0
+        if { ([is-effective-target lp64] && ![istarget *-*-darwin*])
+             || [istarget spu-*-*] } {
+            set et_natural_alignment_64_saved 1
+        }
+    }
+    verbose "check_effective_target_natural_alignment_64: returning $et_natural_alignment_64_saved" 2
+    return $et_natural_alignment_64_saved
+}
+
+
 # Return 1 if vector alignment is reachable, 0 otherwise.
 #
 # This won't change for different subtargets so cache the result.
@@ -2175,7 +2235,7 @@
         verbose "check_effective_target_vector_alignment_reachable: using cached result" 2
     } else {
         if { [check_effective_target_vect_aligned_arrays]
-             || [check_effective_target_natural_alignment] } {
+             || [check_effective_target_natural_alignment_32] } {
             set et_vector_alignment_reachable_saved 1
         } else {
             set et_vector_alignment_reachable_saved 0
@@ -2195,7 +2255,8 @@
     if [info exists et_vector_alignment_reachable_for_double_saved] {
         verbose "check_effective_target_vector_alignment_reachable_for_double: using cached result" 2
     } else {
-        if { [check_effective_target_vect_aligned_arrays] } {
+        if { [check_effective_target_vect_aligned_arrays]
+              || [check_effective_target_natural_alignment_64] } {
             set et_vector_alignment_reachable_for_double_saved 1
         } else {
             set et_vector_alignment_reachable_for_double_saved 0

Re: [patch, testsuite] Fix vectorizer testcases

[Dorit Nuzman]

>
> Fix vectorizer testcases mainly to pass on SPU and 750cl.
>
> Tested on SPU and PowerPC.
> O.K. for mainline?
>

Hi,

please see a few comments below:

> Thanks,
> Revital and Ira
>
> ChangeLog entry:
>
>       * gcc.dg/vect/vect-ifcvt-5.c: Require vect_int.
>       * gcc.dg/vect/pr33369.c: Likewise.
>       * gcc.dg/vect/slp-33.c: Add spaces.
>       * gcc.dg/vect/no-scevccp-outer-18.c: Target vect_interleave.

Generally ChangeLog entries should be real sentances, e.g. instead of the
above write "Enable only for vect_interleave targets" or "Add
vect_interleave target keyword". (Also in other occurences below).

>       * gcc.dg/vect/vect-ifcvt-6.c: Require vect_int.
>       * gcc.dg/vect/no-scevccp-outer-19.c: Xfail on vect_no_shortint_cvt.

You should instead Xfail for targets that don't support vector unpacking
(widening from short to int is achieved by the idioms VEC_UNPACK_HI/LO).
There's already a target keywork for that ("vect_unpack").

>       * gcc.dg/vect/vect-ifcvt-7.c: Require vect_int.
>       * gcc.dg/vect/vect-strided-store-u16-i4.c: Target
> !vect_no_shortint_cvt.

same as above

>       * gcc.dg/vect/slp-10.c: Add spaces.
>       * gcc.dg/vect/no-scevccp-outer-21.c: Xfail on vect_no_intshort_cvt.

You should instead Xfail for targets that don't support vector packing
(narrowing from int to short is achieved by the idiom VEC_PACK_TRUNC).
There's already a target keywork for that ("vect_pack_trunc").

>       * gcc.dg/vect/slp-36.c: Require vect_int.
>       * gcc.dg/vect/vect-strided-store-u32-i2.c,
> gcc.dg/vect/vect-ifcvt-2.c,
>       gcc.dg/vect/vect-ifcvt-3.c, gcc.dg/vect/vect-82.c,
>       gcc.dg/vect/vect-83.c: Likewise.
>       * gcc.dg/vect/no-scevccp-outer-16.c: Xfail on vect_no_shortint_cvt.

Same as above

>       * gcc.dg/vect/no-scevccp-outer-17.c: Likewise.
>       * lib/target-supports.exp (vect_no_intshort_cvt): New.
>       (vect_no_shortint_cvt): New.

As mentioned above, I think there shouldn't be a need for such keywords.

>       (vect_aligned_arrays): Depend on natural_alignment_32.
>       (natural_alignment): Split into...
>       (natural_alignment_32, natural_alignment_64): New.
>       (alignment_reachable_for_double): Depend on natural_alignment_64.
>

About the natural_alignment_32/natural_alignment_64 functions: I would
prefer if a testsuite maintainer could also take a look. The idea is to
differentiate between targets that guarantee natural alignment for types
whose size is 32-bit or less (presumably all targets but 64-bit darwin),
and targets that can also guarantee natural alignment for types whose size
is 64-bit or less (presumably all 64-bit targets but darwin). The question
is whether these two functions indeed implement the above descriptions. (A
separate question is whether these descriptions are correct, but any
testsuite regressions will answer this question...).

> +# Return 1 if types (32 bit and less types) are naturally aligned
> +# (aligned to their type-size), 0 otherwise.

Just w.r.t phrasing: "Return 1 if types of size 32-bit or less are ..."

> @@ -2195,7 +2255,8 @@
>     if [info exists et_vector_alignment_reachable_for_double_saved] {
>         verbose
"check_effective_target_vector_alignment_reachable_for_double: using cached
result" 2
>     } else {
> -        if { [check_effective_target_vect_aligned_arrays] } {
> +        if { [check_effective_target_vect_aligned_arrays]
> +              || [check_effective_target_natural_alignment_64] } {

Maybe we can take this opportunity to change the name of this function to
vector_alignment_reachable_for_64bit (instead of
vector_alignment_reachable_for_double, cause it should be relevant also for
64-bit longs). And also indicate in the documentation of
target_vector_alignment_reachable that it refers to types whose size is
32-bit or less.

ok with above fixes,

thanks,
dorit

> (See attached file: tests.txt)
>
> [attachment "tests.txt" deleted by Dorit Nuzman/Haifa/IBM]

Re: [patch, testsuite] Fix vectorizer testcases

[Dorit Nuzman]

>
> Hello,
>
> OK for mainline?
>

ok,

thanks,
dorit

> Thanks,
> Revital
>
> ChangeLog:
>
>         * testsuite/gcc.dg/vect/vect-shift-1.c: Require vect_int.
>         * testsuite/gcc.dg/vect/vect-ifcvt-4.c: Likewise.
>
>
> Index: testsuite/gcc.dg/vect/vect-shift-1.c
> ===================================================================
> --- testsuite/gcc.dg/vect/vect-shift-1.c        (revision 129655)
> +++ testsuite/gcc.dg/vect/vect-shift-1.c        (working copy)
> @@ -1,4 +1,5 @@
>  /* { dg-require-effective-target vect_shift } */
> +/* { dg-require-effective-target vect_int } */
>
>  #include <stdarg.h>
>  #include "tree-vect.h"
> Index: testsuite/gcc.dg/vect/vect-ifcvt-4.c
> ===================================================================
> --- testsuite/gcc.dg/vect/vect-ifcvt-4.c        (revision 129655)
> +++ testsuite/gcc.dg/vect/vect-ifcvt-4.c        (working copy)
> @@ -1,4 +1,5 @@
>  /* { dg-require-effective-target vect_condition } */
> +/* { dg-require-effective-target vect_int } */
>
>  #include <stdarg.h>
>  #include <signal.h>
>

[patch, testsuite] Fix vectorizer testcases

[Revital1 Eres]

Hello,

OK for mainline?

Thanks,
Revital

ChangeLog:

        * testsuite/gcc.dg/vect/vect-shift-1.c: Require vect_int.
        * testsuite/gcc.dg/vect/vect-ifcvt-4.c: Likewise.


Index: testsuite/gcc.dg/vect/vect-shift-1.c
===================================================================
--- testsuite/gcc.dg/vect/vect-shift-1.c        (revision 129655)
+++ testsuite/gcc.dg/vect/vect-shift-1.c        (working copy)
@@ -1,4 +1,5 @@
 /* { dg-require-effective-target vect_shift } */
+/* { dg-require-effective-target vect_int } */

 #include <stdarg.h>
 #include "tree-vect.h"
Index: testsuite/gcc.dg/vect/vect-ifcvt-4.c
===================================================================
--- testsuite/gcc.dg/vect/vect-ifcvt-4.c        (revision 129655)
+++ testsuite/gcc.dg/vect/vect-ifcvt-4.c        (working copy)
@@ -1,4 +1,5 @@
 /* { dg-require-effective-target vect_condition } */
+/* { dg-require-effective-target vect_int } */

 #include <stdarg.h>
 #include <signal.h>