[PATCH] Another fix to the misaligned store vectorizer patch

[Revital1 Eres]

Hello,

I mistakenly allowed peeling for alignment to be considered for loads
(instead of only stores as the original behavior).  This can effect
targets which does not support misalign stores but support misalign
loads -- for these targets we have more chances to vectorize a loop
if we peel for stores as the loads are already supported (i.e., satisfy
vect_supportable_dr_alignment).
This patch fixes it.

Bootstrapped with vectorization enabled on powerpc64 and regtested
on x86_64 and ppc.

OK for mainline?

Thanks,
Revital

ChangeLog:

testsuite/
        * gcc.target/powerpc/vsx-vectorize-3.c: Adjust tetcase following
        change in decision of peeling for alignment.
        * gcc.target/powerpc/vsx-vectorize-5.c: Likewise.
        * gcc.dg/vect/vect-50.c: Likewise.
        * gcc.dg/vect/vect-42.c: Likewise.
        * gcc.dg/vect/costmodel/i386/costmodel-fast-math-vect-pr29925.c:
        Likewise.
        * gcc.dg/vect/costmodel/x86_64/costmodel-fast-math-vect-pr29925.c:
        Likewise.
        * gcc.dg/vect/vect-multitypes-6.c: Likewise.
        * gcc.dg/vect/vect-60.c: Likewise.
        * gcc.dg/vect/vect-52.c: Likewise.
        * gcc.dg/vect/vect-44.c: Likewise.
        * gcc.dg/vect/vect-27.c: Likewise.
        * gcc.dg/vect/vect-29.c: Likewise.
        * gcc.dg/vect/vect-72.c: Likewise.
        * gcc.dg/vect/vect-56.c: Likewise.
        * gcc.dg/vect/vect-48.c: Likewise.
        * gcc.dg/vect/vect-multitypes-3.c: Likewise.
        * gfortran.dg/vect/vect-2.f90: Likewise.
        * gfortran.dg/vect/vect-5.f90: Likewise.

gcc/
        * tree-vect-data-refs.c: Consider peeling for alignment only
        for stores and remove redundant assignment.

(See attached file: patch_misalign_4_11.txt)
Index: testsuite/gcc.target/powerpc/vsx-vectorize-3.c
===================================================================
--- testsuite/gcc.target/powerpc/vsx-vectorize-3.c (revision 153841)
+++ testsuite/gcc.target/powerpc/vsx-vectorize-3.c (working copy)
@@ -54,7 +54,7 @@ int main (void)
 }
 
 /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
-/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" {xfail {! vect_hw_misalign } } } } */
-/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 0 "vect" {xfail {! vect_hw_misalign } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 0 "vect" } } */
 /* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
Index: testsuite/gcc.target/powerpc/vsx-vectorize-5.c
===================================================================
--- testsuite/gcc.target/powerpc/vsx-vectorize-5.c (revision 153841)
+++ testsuite/gcc.target/powerpc/vsx-vectorize-5.c (working copy)
@@ -54,7 +54,7 @@ int main (void)
 }
 
 /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
-/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" {xfail {! vect_hw_misalign } } } } */
-/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 0 "vect" {xfail {! vect_hw_misalign } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 0 "vect" } } */
 /* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
Index: testsuite/gcc.dg/vect/vect-50.c
===================================================================
--- testsuite/gcc.dg/vect/vect-50.c (revision 153841)
+++ testsuite/gcc.dg/vect/vect-50.c (working copy)
@@ -63,7 +63,7 @@ int main (void)
 /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
 /* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail { vect_no_align } } } }  */
 /* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { target vect_hw_misalign } } } */
-/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail { { vect_no_align || {! vect_hw_misalign } } || {! vector_alignment_reachable} } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail { vect_no_align || {! vector_alignment_reachable} } } } } */
 /* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 3 "vect" { target vect_no_align } } } */
 /* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 1 "vect" { target { {! vector_alignment_reachable} && { {! vect_no_align } && {! vect_hw_misalign } } } } } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
Index: testsuite/gcc.dg/vect/vect-42.c
===================================================================
--- testsuite/gcc.dg/vect/vect-42.c (revision 153841)
+++ testsuite/gcc.dg/vect/vect-42.c (working copy)
@@ -65,6 +65,6 @@ int main (void)
 /* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
 /* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 3 "vect" { target vect_no_align } } } */
 /* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 1 "vect" { target { { ! vector_alignment_reachable } && { ! vect_hw_misalign } } } } } */
-/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 4 "vect" { xfail { { vect_no_align || vect_hw_misalign } || { ! vector_alignment_reachable } } } } } */
-/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail { { vect_no_align || vect_hw_misalign } || { ! vector_alignment_reachable } } } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 4 "vect" { xfail { vect_no_align || { ! vector_alignment_reachable } } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail { vect_no_align || { ! vector_alignment_reachable } } } } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
Index: testsuite/gcc.dg/vect/costmodel/i386/costmodel-fast-math-vect-pr29925.c
===================================================================
--- testsuite/gcc.dg/vect/costmodel/i386/costmodel-fast-math-vect-pr29925.c (revision 153841)
+++ testsuite/gcc.dg/vect/costmodel/i386/costmodel-fast-math-vect-pr29925.c (working copy)
@@ -35,6 +35,6 @@ int main()
    return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { xfail vect_hw_misalign } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
 
Index: testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-fast-math-vect-pr29925.c
===================================================================
--- testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-fast-math-vect-pr29925.c (revision 153841)
+++ testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-fast-math-vect-pr29925.c (working copy)
@@ -35,6 +35,6 @@ int main()
    return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail vect_hw_misalign } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
 
Index: testsuite/gcc.dg/vect/vect-multitypes-6.c
===================================================================
--- testsuite/gcc.dg/vect/vect-multitypes-6.c (revision 153841)
+++ testsuite/gcc.dg/vect/vect-multitypes-6.c (working copy)
@@ -61,6 +61,6 @@ int main (void)
 
 /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
 /*  { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 6 "vect" { target vect_no_align } } } */
-/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 6 "vect" {xfail { vect_no_align || vect_hw_misalign } } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 6 "vect" {xfail { vect_no_align } } } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
 
Index: testsuite/gcc.dg/vect/vect-60.c
===================================================================
--- testsuite/gcc.dg/vect/vect-60.c (revision 153841)
+++ testsuite/gcc.dg/vect/vect-60.c (working copy)
@@ -69,6 +69,6 @@ int main (void)
 }
 
 /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail vect_no_align } } } */
-/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail { vect_no_align || vect_hw_misalign } } } } */
-/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" { xfail vect_hw_misalign } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail { vect_no_align } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
Index: testsuite/gcc.dg/vect/vect-52.c
===================================================================
--- testsuite/gcc.dg/vect/vect-52.c (revision 153841)
+++ testsuite/gcc.dg/vect/vect-52.c (working copy)
@@ -56,6 +56,6 @@ int main (void)
 
 /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
 /* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail vect_no_align } } } */
-/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" {xfail {! vect_hw_misalign } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
 /* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 2 "vect" { target vect_no_align } } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
Index: testsuite/gcc.dg/vect/vect-44.c
===================================================================
--- testsuite/gcc.dg/vect/vect-44.c (revision 153841)
+++ testsuite/gcc.dg/vect/vect-44.c (working copy)
@@ -66,7 +66,7 @@ int main (void)
 
 /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
 /* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail { vect_no_align } } } } */
-/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail { { vect_no_align || {! vect_hw_misalign } } || {! vector_alignment_reachable} } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail { vect_no_align || {! vector_alignment_reachable} } } } } */
 /* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 3 "vect" { target vect_no_align } } } */
 /* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 1 "vect" { target { {! vector_alignment_reachable} && {{! vect_no_align} && {! vect_hw_misalign} } } } } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
Index: testsuite/gcc.dg/vect/vect-27.c
===================================================================
--- testsuite/gcc.dg/vect/vect-27.c (revision 153841)
+++ testsuite/gcc.dg/vect/vect-27.c (working copy)
@@ -46,5 +46,5 @@ int main (void)
 /* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" { xfail vect_no_align } } } */
 /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_no_align } } } */
 /* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 1 "vect" { xfail vect_no_align } } } */
-/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail {! vect_hw_misalign} } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
Index: testsuite/gcc.dg/vect/vect-29.c
===================================================================
--- testsuite/gcc.dg/vect/vect-29.c (revision 153841)
+++ testsuite/gcc.dg/vect/vect-29.c (working copy)
@@ -51,6 +51,6 @@ int main (void)
 /* The initialization induction loop (with aligned access) is also vectorized.  */
 /* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
 /* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 1 "vect" { xfail vect_no_align } } } */
-/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" { xfail vect_hw_misalign } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
 /* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 1 "vect" {target vect_no_align } } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
Index: testsuite/gcc.dg/vect/vect-72.c
===================================================================
--- testsuite/gcc.dg/vect/vect-72.c (revision 153841)
+++ testsuite/gcc.dg/vect/vect-72.c (working copy)
@@ -47,5 +47,5 @@ int main (void)
 
 /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail vect_no_align } } } */
 /* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 1 "vect" { xfail vect_no_align } } } */
-/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" { xfail vect_hw_misalign } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
Index: testsuite/gcc.dg/vect/vect-56.c
===================================================================
--- testsuite/gcc.dg/vect/vect-56.c (revision 153841)
+++ testsuite/gcc.dg/vect/vect-56.c (working copy)
@@ -68,6 +68,6 @@ int main (void)
 }
 
 /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail vect_no_align } } } */
-/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail { vect_no_align || vect_hw_misalign } } } } */
-/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail {! vect_hw_misalign } } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail { vect_no_align } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
Index: testsuite/gcc.dg/vect/vect-48.c
===================================================================
--- testsuite/gcc.dg/vect/vect-48.c (revision 153841)
+++ testsuite/gcc.dg/vect/vect-48.c (working copy)
@@ -55,6 +55,6 @@ int main (void)
 
 /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  } } */
 /* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail vect_no_align } } } */
-/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail {! vect_hw_misalign } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
 /* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 2 "vect" { target vect_no_align } } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
Index: testsuite/gcc.dg/vect/vect-multitypes-3.c
===================================================================
--- testsuite/gcc.dg/vect/vect-multitypes-3.c (revision 153841)
+++ testsuite/gcc.dg/vect/vect-multitypes-3.c (working copy)
@@ -54,6 +54,6 @@ int main (void)
 
 /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
 /*  { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 3 "vect" { target vect_no_align } } } */
-/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 3 "vect" {xfail { vect_no_align || vect_hw_misalign } } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 3 "vect" {xfail { vect_no_align } } } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
 
Index: testsuite/gfortran.dg/vect/vect-2.f90
===================================================================
--- testsuite/gfortran.dg/vect/vect-2.f90 (revision 153841)
+++ testsuite/gfortran.dg/vect/vect-2.f90 (working copy)
@@ -15,7 +15,7 @@ END
 ! support unaligned loads).
 
 ! { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" } }
-! { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 3 "vect" { xfail { { vect_no_align || { ! vect_hw_misalign } } || { ! vector_alignment_reachable } } } } }
+! { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 3 "vect" { xfail { vect_no_align || { ! vector_alignment_reachable } } } } }
 ! { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 2 "vect" { target { vect_no_align && { ! vector_alignment_reachable } } } } }
 ! { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail { vect_no_align } } } }
 ! { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 3 "vect" {target { vect_no_align || { { ! vector_alignment_reachable  } && { ! vect_hw_misalign } } } } } }
Index: testsuite/gfortran.dg/vect/vect-5.f90
===================================================================
--- testsuite/gfortran.dg/vect/vect-5.f90 (revision 153841)
+++ testsuite/gfortran.dg/vect/vect-5.f90 (working copy)
@@ -36,7 +36,7 @@
         end
 
 ! { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  } }
-! { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail { { vect_no_align || {! vect_hw_misalign } } || {! vector_alignment_reachable} } } } }
+! { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail { vect_no_align || {! vector_alignment_reachable} } } } }
 ! { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 1 "vect" { xfail { vect_no_align } } } }
 ! { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 2 "vect" { target { vect_no_align } } } }
 ! { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 1 "vect" { target { {! vector_alignment_reachable} && {! vect_hw_misalign} } } } }
Index: tree-vect-data-refs.c
===================================================================
--- tree-vect-data-refs.c (revision 153841)
+++ tree-vect-data-refs.c (working copy)
@@ -1176,7 +1176,6 @@ vect_enhance_data_refs_alignment (loop_v
     {
       stmt = DR_STMT (dr);
       stmt_info = vinfo_for_stmt (stmt);
-      supportable_dr_alignment = vect_supportable_dr_alignment (dr);
 
       /* For interleaving, only the alignment of the first access
          matters.  */
@@ -1184,7 +1183,7 @@ vect_enhance_data_refs_alignment (loop_v
           && DR_GROUP_FIRST_DR (stmt_info) != stmt)
         continue;
 
-      if (!aligned_access_p (dr))
+      if (!DR_IS_READ (dr) && !aligned_access_p (dr))
         {
   do_peeling = vector_alignment_reachable_p (dr);
   if (do_peeling)

[Ira Rosen]

gcc-patches-owner@... wrote on 04/11/2009 11:26:22:

> Revital1 Eres/Haifa/IBM@IBMIL
> Sent by: gcc-patches-owner@...
>
> 04/11/2009 11:26
>
> To
>
> gcc-patches@...
>
> cc
>
> Subject
>
> [PATCH] Another fix to the misaligned store vectorizer patch
>
>
> Hello,
>
> I mistakenly allowed peeling for alignment to be considered for loads
> (instead of only stores as the original behavior).  This can effect
> targets which does not support misalign stores but support misalign
> loads -- for these targets we have more chances to vectorize a loop
> if we peel for stores as the loads are already supported (i.e., satisfy
> vect_supportable_dr_alignment).
> This patch fixes it.
>
> Bootstrapped with vectorization enabled on powerpc64 and regtested
> on x86_64 and ppc.
>
> OK for mainline?
>

OK.

Thanks,
Ira

> Thanks,
> Revital
>
> ChangeLog:
>
> testsuite/
>         * gcc.target/powerpc/vsx-vectorize-3.c: Adjust tetcase following
>         change in decision of peeling for alignment.
>         * gcc.target/powerpc/vsx-vectorize-5.c: Likewise.
>         * gcc.dg/vect/vect-50.c: Likewise.
>         * gcc.dg/vect/vect-42.c: Likewise.
>         * gcc.dg/vect/costmodel/i386/costmodel-fast-math-vect-pr29925.c:
>         Likewise.
>         *

gcc.dg/vect/costmodel/x86_64/costmodel-fast-math-vect-pr29925.c:

>         Likewise.
>         * gcc.dg/vect/vect-multitypes-6.c: Likewise.
>         * gcc.dg/vect/vect-60.c: Likewise.
>         * gcc.dg/vect/vect-52.c: Likewise.
>         * gcc.dg/vect/vect-44.c: Likewise.
>         * gcc.dg/vect/vect-27.c: Likewise.
>         * gcc.dg/vect/vect-29.c: Likewise.
>         * gcc.dg/vect/vect-72.c: Likewise.
>         * gcc.dg/vect/vect-56.c: Likewise.
>         * gcc.dg/vect/vect-48.c: Likewise.
>         * gcc.dg/vect/vect-multitypes-3.c: Likewise.
>         * gfortran.dg/vect/vect-2.f90: Likewise.
>         * gfortran.dg/vect/vect-5.f90: Likewise.
>
> gcc/
>         * tree-vect-data-refs.c: Consider peeling for alignment only
>         for stores and remove redundant assignment.
>
> (See attached file: patch_misalign_4_11.txt)[attachment
> "patch_misalign_4_11.txt" deleted by Ira Rosen/Haifa/IBM]

[Uros Bizjak-3]

Hello!

> I mistakenly allowed peeling for alignment to be considered for loads
> (instead of only stores as the original behavior).  This can effect
> targets which does not support misalign stores but support misalign
> loads -- for these targets we have more chances to vectorize a loop
> if we peel for stores as the loads are already supported (i.e., satisfy
> vect_supportable_dr_alignment).
> This patch fixes it.

> Bootstrapped with vectorization enabled on powerpc64 and regtested
> on x86_64 and ppc.

It looks that this patch again caused a runtime regressed in test_fpu, see [1].

[1] http://gcc.opensuse.org/c++bench/polyhedron/polyhedron-summary.txt-2-0.html

Uros.

[Revital1 Eres]

Hello Uros,
>
> It looks that this patch again caused a runtime regressed in test_fpu,
see [1].
>
> [1] http://gcc.opensuse.org/c+
+bench/polyhedron/polyhedron-summary.txt-2-0.html

It looks like the patch retrieves the results to be as before
the misaligned store vectorizer patch was committed (until 5/09), right?
(it's effect
can be seen between 2009-06-05 and 2009-06-06).
The latest submission which seems to give a speed-up (2009-10-27 and
2009-10-28) consider peeling for alignment also for loads; but as was
mentioned in the submission email it might hurt targets that does not
support misalign stores.
Anyway, I am now working on a patch to change that
based on cost model but that would be considered only for stage 1.

Thanks,
Revital

>
> Uros.