gcc/testsuite/gcc.dg/vect/vect-early-break_56.c

   1 /* { dg-add-options vect_early_break } */
   2 /* Disabling epilogues until we find a better way to deal with scans.  */
   3 /* { dg-additional-options "--param vect-epilogues-nomask=0" } */
   4 /* { dg-require-effective-target vect_int } */
   5 /* { dg-add-options bind_pic_locally } */
   6 /* { dg-require-effective-target vect_early_break_hw } */
   7
   8 #include <stdarg.h>
   9 #include "tree-vect.h"
  10
  11 #define N 32
  12
  13 unsigned short sa[N];
  14 unsigned short sc[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,
  15                 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
  16 unsigned short sb[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,
  17                 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
  18 unsigned int ia[N];
  19 unsigned int ic[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,
  20                0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
  21 unsigned int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,
  22                0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
  23
  24 /* Current peeling-for-alignment scheme will consider the 'sa[i+7]'
  25    access for peeling, and therefore will examine the option of
  26    using a peeling factor = VF-7%VF. This will result in a peeling factor 1,
  27    which will also align the access to 'ia[i+3]', and the loop could be
  28    vectorized on all targets that support unaligned loads.
  29    Without cost model on targets that support misaligned stores, no peeling
  30    will be applied since we want to keep the four loads aligned.  */
  31
  32 __attribute__ ((noinline))
  33 int main1 ()
  34 {
  35   int i;
  36   int n = N - 7;
  37
  38   /* Multiple types with different sizes, used in independent
  39      copmutations. Vectorizable.  */
  40   for (i = 0; i < n; i++)
  41     {
  42       sa[i+7] = sb[i] + sc[i];
  43       ia[i+3] = ib[i] + ic[i];
  44     }
  45
  46   /* check results:  */
  47   for (i = 0; i < n; i++)
  48     {
  49       if (sa[i+7] != sb[i] + sc[i] || ia[i+3] != ib[i] + ic[i])
  50         abort ();
  51     }
  52
  53   return 0;
  54 }
  55
  56 /* Current peeling-for-alignment scheme will consider the 'ia[i+3]'
  57    access for peeling, and therefore will examine the option of
  58    using a peeling factor = VF-3%VF. This will result in a peeling factor
  59    1 if VF=4,2. This will not align the access to 'sa[i+3]', for which we
  60    need to peel 5,1 iterations for VF=4,2 respectively, so the loop can not
  61    be vectorized.  However, 'ia[i+3]' also gets aligned if we peel 5
  62    iterations, so the loop is vectorizable on all targets that support
  63    unaligned loads.
  64    Without cost model on targets that support misaligned stores, no peeling
  65    will be applied since we want to keep the four loads aligned.  */
  66
  67 __attribute__ ((noinline))
  68 int main2 ()
  69 {
  70   int i;
  71   int n = N-3;
  72
  73   /* Multiple types with different sizes, used in independent
  74      copmutations. Vectorizable.  */
  75   for (i = 0; i < n; i++)
  76     {
  77       ia[i+3] = ib[i] + ic[i];
  78       sa[i+3] = sb[i] + sc[i];
  79     }
  80
  81   /* check results:  */
  82   for (i = 0; i < n; i++)
  83     {
  84       if (sa[i+3] != sb[i] + sc[i] || ia[i+3] != ib[i] + ic[i])
  85         abort ();
  86     }
  87
  88   return 0;
  89 }
  90
  91 int main (void)
  92 {
  93   check_vect ();
  94
  95   main1 ();
  96   main2 ();
  97
  98   return 0;
  99 }
 100
 101 /* { dg-final { scan-tree-dump-times "vectorized 2 loops" 2 "vect" { xfail { vect_early_break && { ! vect_hw_misalign } } } } } */
 102