gcc/testsuite/gfortran.dg/loop_versioning_6.f90

   1 ! { dg-options "-O3 -fdump-tree-lversion-details" }
   2
   3 ! Check that versioning can handle small groups of accesses.
   4
   5 subroutine f1(x)
   6   real :: x(:)
   7   do i = lbound(x, 1), ubound(x, 1) / 2
   8      x(i * 2) = 100
   9      x(i * 2 + 1) = 101
  10   end do
  11 end subroutine f1
  12
  13 subroutine f2(x, n, step)
  14   integer :: n, step
  15   real :: x(n * step * 2)
  16   do i = 1, n
  17      x(i * step * 2) = 100
  18      x(i * step * 2 + 1) = 101
  19   end do
  20 end subroutine f2
  21
  22 subroutine f3(x, limit, step)
  23   integer :: limit, step
  24   real :: x(limit * 2)
  25   do i = 1, limit, step
  26      x(i * 2) = 100
  27      x(i * 2 + 1) = 101
  28   end do
  29 end subroutine f3
  30
  31 subroutine f4(x)
  32   real :: x(:)
  33   do i = lbound(x, 1), ubound(x, 1) / 3
  34      x(i * 3) = 100
  35      x(i * 3 + 1) = 101
  36      x(i * 3 + 2) = 102
  37   end do
  38 end subroutine f4
  39
  40 subroutine f5(x, n, step)
  41   integer :: n, step
  42   real :: x(n * step * 3)
  43   do i = 1, n
  44      x(i * step * 3) = 100
  45      x(i * step * 3 + 1) = 101
  46      x(i * step * 3 + 2) = 102
  47   end do
  48 end subroutine f5
  49
  50 subroutine f6(x, limit, step)
  51   integer :: limit, step
  52   real :: x(limit * 3)
  53   do i = 1, limit, step
  54      x(i * 3) = 100
  55      x(i * 3 + 1) = 101
  56      x(i * 3 + 2) = 102
  57   end do
  58 end subroutine f6
  59
  60 subroutine f7(x)
  61   real :: x(:)
  62   do i = lbound(x, 1), ubound(x, 1) / 4
  63      x(i * 4) = 100
  64      x(i * 4 + 1) = 101
  65      x(i * 4 + 2) = 102
  66      x(i * 4 + 3) = 103
  67   end do
  68 end subroutine f7
  69
  70 subroutine f8(x, n, step)
  71   integer :: n, step
  72   real :: x(n * step * 4)
  73   do i = 1, n
  74      x(i * step * 4) = 100
  75      x(i * step * 4 + 1) = 101
  76      x(i * step * 4 + 2) = 102
  77      x(i * step * 4 + 3) = 103
  78   end do
  79 end subroutine f8
  80
  81 subroutine f9(x, limit, step)
  82   integer :: limit, step
  83   real :: x(limit * 4)
  84   do i = 1, limit, step
  85      x(i * 4) = 100
  86      x(i * 4 + 1) = 101
  87      x(i * 4 + 2) = 102
  88      x(i * 4 + 3) = 103
  89   end do
  90 end subroutine f9
  91
  92 ! { dg-final { scan-tree-dump-times {want to version containing loop} 9 "lversion" { xfail { ! lp64 } } } }
  93 ! { dg-final { scan-tree-dump-times {versioned this loop} 9 "lversion" { xfail { ! lp64 } } } }