libgomp/testsuite/libgomp.oacc-fortran/private-variables.f90

   1 ! Miscellaneous tests for private variables.
   2
   3 ! { dg-do run }
   4
   5 ! { dg-additional-options "-fopt-info-note-omp" }
   6 ! { dg-additional-options "--param=openacc-privatization=noisy" }
   7 ! { dg-additional-options "-foffload=-fopt-info-note-omp" }
   8 ! { dg-additional-options "-foffload=--param=openacc-privatization=noisy" }
   9 ! for testing/documenting aspects of that functionality.
  10
  11 ! { dg-additional-options "-Wopenacc-parallelism" } for testing/documenting
  12 ! aspects of that functionality.
  13
  14 ! It's only with Tcl 8.5 (released in 2007) that "the variable 'varName'
  15 ! passed to 'incr' may be unset, and in that case, it will be set to [...]",
  16 ! so to maintain compatibility with earlier Tcl releases, we manually
  17 ! initialize counter variables:
  18 ! { dg-line l_dummy[variable c_loop 0] }
  19 ! { dg-message "dummy" "" { target iN-VAl-Id } l_dummy } to avoid
  20 ! "WARNING: dg-line var l_dummy defined, but not used".
  21
  22
  23 ! Test of gang-private variables declared on loop directive.
  24
  25 subroutine t1()
  26   integer :: x, i, arr(32)
  27
  28   do i = 1, 32
  29      arr(i) = i
  30   end do
  31
  32   !$acc parallel copy(arr) num_gangs(32) num_workers(8) vector_length(32)
  33   ! { dg-warning "region is worker partitioned but does not contain worker partitioned code" "" { target *-*-* } .-1 }
  34   ! { dg-warning "region is vector partitioned but does not contain vector partitioned code" "" { target *-*-* } .-2 }
  35   !$acc loop gang private(x) ! { dg-line l_loop[incr c_loop] }
  36   ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
  37   ! { dg-note {variable 'x' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
  38   do i = 1, 32
  39      x = i * 2;
  40      arr(i) = arr(i) + x
  41   end do
  42   !$acc end parallel
  43
  44   do i = 1, 32
  45      if (arr(i) .ne. i * 3) STOP 1
  46   end do
  47 end subroutine t1
  48
  49
  50 ! Test of gang-private variables declared on loop directive, with broadcasting
  51 ! to partitioned workers.
  52
  53 subroutine t2()
  54   integer :: x, i, j, arr(0:32*32)
  55
  56   do i = 0, 32*32-1
  57      arr(i) = i
  58   end do
  59
  60   !$acc parallel copy(arr) num_gangs(32) num_workers(8) vector_length(32)
  61   ! { dg-warning "region is vector partitioned but does not contain vector partitioned code" "" { target *-*-* } .-1 }
  62   !$acc loop gang private(x) ! { dg-line l_loop[incr c_loop] }
  63   ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
  64   ! { dg-note {variable 'x' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
  65   do i = 0, 31
  66      x = i * 2;
  67
  68      !$acc loop worker ! { dg-line l_loop[incr c_loop] }
  69      ! { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
  70      do j = 0, 31
  71         arr(i * 32 + j) = arr(i * 32 + j) + x
  72      end do
  73   end do
  74   !$acc end parallel
  75
  76   do i = 0, 32 * 32 - 1
  77      if (arr(i) .ne. i + (i / 32) * 2) STOP 2
  78   end do
  79 end subroutine t2
  80
  81
  82 ! Test of gang-private variables declared on loop directive, with broadcasting
  83 ! to partitioned vectors.
  84
  85 subroutine t3()
  86   integer :: x, i, j, arr(0:32*32)
  87
  88   do i = 0, 32*32-1
  89      arr(i) = i
  90   end do
  91
  92   !$acc parallel copy(arr) num_gangs(32) num_workers(8) vector_length(32)
  93   ! { dg-warning "region is worker partitioned but does not contain worker partitioned code" "" { target *-*-* } .-1 }
  94   !$acc loop gang private(x) ! { dg-line l_loop[incr c_loop] }
  95   ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
  96   ! { dg-note {variable 'x' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
  97   do i = 0, 31
  98      x = i * 2;
  99
 100      !$acc loop vector ! { dg-line l_loop[incr c_loop] }
 101      ! { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 102      do j = 0, 31
 103         arr(i * 32 + j) = arr(i * 32 + j) + x
 104      end do
 105   end do
 106   !$acc end parallel
 107
 108   do i = 0, 32 * 32 - 1
 109      if (arr(i) .ne. i + (i / 32) * 2) STOP 3
 110   end do
 111 end subroutine t3
 112
 113
 114 ! Test of gang-private addressable variable declared on loop directive, with
 115 ! broadcasting to partitioned workers.
 116
 117 subroutine t4()
 118   type vec3
 119      integer x, y, z, attr(13)
 120   end type vec3
 121
 122   integer i, j, arr(0:32*32)
 123   type(vec3) pt
 124
 125   do i = 0, 32*32-1
 126      arr(i) = i
 127   end do
 128
 129   !$acc parallel copy(arr) num_gangs(32) num_workers(8) vector_length(32)
 130   ! { dg-warning "region is worker partitioned but does not contain worker partitioned code" "" { target *-*-* } .-1 }
 131   !$acc loop gang private(pt) ! { dg-line l_loop[incr c_loop] }
 132   ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 133   ! { dg-note {variable 'pt' in 'private' clause is candidate for adjusting OpenACC privatization level} "" { target *-*-* } l_loop$c_loop }
 134   ! But, with optimizations enabled, per the '*.ssa' dump ('gcc/tree-ssa.c:execute_update_addresses_taken'):
 135   !     No longer having address taken: pt
 136   ! However, 'pt' remains in the candidate set:
 137   ! { dg-note {variable 'pt' ought to be adjusted for OpenACC privatization level: 'gang'} "" { target *-*-* } l_loop$c_loop }
 138   ! Now, for GCN offloading, 'adjust_private_decl' does the privatization change right away:
 139   ! { dg-note {variable 'pt' adjusted for OpenACC privatization level: 'gang'} "" { target openacc_radeon_accel_selected } l_loop$c_loop }
 140   ! For nvptx offloading however, we first mark up 'pt', and then later apply the privatization change -- or, with optimizations enabled, don't, because we then don't actually call 'expand_var_decl'.
 141   ! { dg-note {variable 'pt' adjusted for OpenACC privatization level: 'gang'} "" { target { openacc_nvidia_accel_selected && { ! __OPTIMIZE__ } } } l_loop$c_loop }
 142   ! { dg-bogus {note: variable 'pt' adjusted for OpenACC privatization level: 'gang'} "" { target { openacc_nvidia_accel_selected && __OPTIMIZE__ } } l_loop$c_loop }
 143   do i = 0, 31
 144      pt%x = i
 145      pt%y = i * 2
 146      pt%z = i * 4
 147      pt%attr(5) = i * 6
 148
 149      !$acc loop vector ! { dg-line l_loop[incr c_loop] }
 150      ! { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 151      do j = 0, 31
 152         arr(i * 32 + j) = arr(i * 32 + j) + pt%x + pt%y + pt%z + pt%attr(5);
 153      end do
 154   end do
 155   !$acc end parallel
 156
 157   do i = 0, 32 * 32 - 1
 158      if (arr(i) .ne. i + (i / 32) * 13) STOP 4
 159   end do
 160 end subroutine t4
 161
 162
 163 ! Test of vector-private variables declared on loop directive.
 164
 165 subroutine t5()
 166   integer :: x, i, j, k, idx, arr(0:32*32*32)
 167
 168   do i = 0, 32*32*32-1
 169      arr(i) = i
 170   end do
 171
 172   !$acc parallel copy(arr) num_gangs(32) num_workers(8) vector_length(32)
 173   !$acc loop gang ! { dg-line l_loop[incr c_loop] }
 174   ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 175   do i = 0, 31
 176      !$acc loop worker ! { dg-line l_loop[incr c_loop] }
 177      ! { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 178      do j = 0, 31
 179         !$acc loop vector private(x) ! { dg-line l_loop[incr c_loop] }
 180         ! { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 181         ! { dg-note {variable 'x' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 182         do k = 0, 31
 183            x = ieor(i, j * 3)
 184            arr(i * 1024 + j * 32 + k) = arr(i * 1024 + j * 32 + k) + x * k
 185         end do
 186         !$acc loop vector private(x) ! { dg-line l_loop[incr c_loop] }
 187         ! { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 188         ! { dg-note {variable 'x' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 189         do k = 0, 31
 190            x = ior(i, j * 5)
 191            arr(i * 1024 + j * 32 + k) = arr(i * 1024 + j * 32 + k) + x * k
 192         end do
 193      end do
 194   end do
 195   !$acc end parallel
 196
 197   do i = 0, 32 - 1
 198      do j = 0, 32 -1
 199         do k = 0, 32 - 1
 200            idx = i * 1024 + j * 32 + k
 201            if (arr(idx) .ne. idx + ieor(i, j * 3) * k + ior(i, j * 5) * k) then
 202               STOP 5
 203            end if
 204         end do
 205      end do
 206   end do
 207 end subroutine t5
 208
 209
 210 ! Test of vector-private variables declared on loop directive. Array type.
 211
 212 subroutine t6()
 213   integer :: i, j, k, idx, arr(0:32*32*32), pt(2)
 214
 215   do i = 0, 32*32*32-1
 216      arr(i) = i
 217   end do
 218
 219   !$acc parallel copy(arr) num_gangs(32) num_workers(8) vector_length(32)
 220   !$acc loop gang ! { dg-line l_loop[incr c_loop] }
 221   ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 222   do i = 0, 31
 223      !$acc loop worker ! { dg-line l_loop[incr c_loop] }
 224      ! { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 225      do j = 0, 31
 226         !$acc loop vector private(x, pt) ! { dg-line l_loop[incr c_loop] }
 227         ! { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 228         ! { dg-bogus {note: variable 'x' in 'private' clause} "" { target *-*-* } l_loop$c_loop }
 229         ! { dg-note {variable 'pt' in 'private' clause is candidate for adjusting OpenACC privatization level} "" { target *-*-* } l_loop$c_loop }
 230         ! { dg-note {variable 'pt' ought to be adjusted for OpenACC privatization level: 'vector'} "" { target *-*-* } l_loop$c_loop }
 231         ! { dg-note {variable 'pt' adjusted for OpenACC privatization level: 'vector'} "" { target { ! openacc_host_selected } } l_loop$c_loop }
 232         do k = 0, 31
 233            pt(1) = ieor(i, j * 3)
 234            pt(2) = ior(i, j * 5)
 235            arr(i * 1024 + j * 32 + k) = arr(i * 1024 + j * 32 + k) + pt(1) * k
 236            arr(i * 1024 + j * 32 + k) = arr(i * 1024 + j * 32 + k) + pt(2) * k
 237         end do
 238      end do
 239   end do
 240   !$acc end parallel
 241
 242   do i = 0, 32 - 1
 243      do j = 0, 32 -1
 244         do k = 0, 32 - 1
 245            idx = i * 1024 + j * 32 + k
 246            if (arr(idx) .ne. idx + ieor(i, j * 3) * k + ior(i, j * 5) * k) then
 247               STOP 6
 248            end if
 249         end do
 250      end do
 251   end do
 252 end subroutine t6
 253
 254
 255 ! Test of worker-private variables declared on a loop directive.
 256
 257 subroutine t7()
 258   integer :: x, i, j, arr(0:32*32)
 259   common x
 260
 261   do i = 0, 32*32-1
 262      arr(i) = i
 263   end do
 264
 265   !$acc parallel copy(arr) num_gangs(32) num_workers(8) vector_length(32)
 266   ! { dg-warning "region is vector partitioned but does not contain vector partitioned code" "" { target *-*-* } .-1 }
 267   !$acc loop gang private(x) ! { dg-line l_loop[incr c_loop] }
 268   ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 269   ! { dg-bogus {note: variable 'x' in 'private' clause} "" { target *-*-* } l_loop$c_loop }
 270   do i = 0, 31
 271      !$acc loop worker private(x) ! { dg-line l_loop[incr c_loop] }
 272      ! { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 273      ! { dg-note {variable 'x' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 274      do j = 0, 31
 275         x = ieor(i, j * 3)
 276         arr(i * 32 + j) = arr(i * 32 + j) + x
 277      end do
 278   end do
 279   !$acc end parallel
 280
 281   do i = 0, 32 * 32 - 1
 282      if (arr(i) .ne. i + ieor(i / 32, mod(i, 32) * 3)) STOP 7
 283   end do
 284 end subroutine t7
 285
 286
 287 ! Test of worker-private variables declared on a loop directive, broadcasting
 288 ! to vector-partitioned mode.
 289
 290 subroutine t8()
 291   integer :: x, i, j, k, idx, arr(0:32*32*32)
 292
 293   do i = 0, 32*32*32-1
 294      arr(i) = i
 295   end do
 296
 297   !$acc parallel copy(arr) num_gangs(32) num_workers(8) vector_length(32)
 298   !$acc loop gang ! { dg-line l_loop[incr c_loop] }
 299   ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 300   do i = 0, 31
 301      !$acc loop worker private(x) ! { dg-line l_loop[incr c_loop] }
 302      ! { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 303      ! { dg-note {variable 'x' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 304      do j = 0, 31
 305         x = ieor(i, j * 3)
 306
 307         !$acc loop vector ! { dg-line l_loop[incr c_loop] }
 308         ! { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 309         do k = 0, 31
 310            arr(i * 1024 + j * 32 + k) = arr(i * 1024 + j * 32 + k) + x * k
 311         end do
 312      end do
 313   end do
 314   !$acc end parallel
 315
 316   do i = 0, 32 - 1
 317      do j = 0, 32 -1
 318         do k = 0, 32 - 1
 319            idx = i * 1024 + j * 32 + k
 320            if (arr(idx) .ne. idx + ieor(i, j * 3) * k) STOP 8
 321         end do
 322      end do
 323   end do
 324 end subroutine t8
 325
 326
 327 ! Test of worker-private variables declared on a loop directive, broadcasting
 328 ! to vector-partitioned mode.  Back-to-back worker loops.
 329
 330 subroutine t9()
 331   integer :: x, i, j, k, idx, arr(0:32*32*32)
 332
 333   do i = 0, 32*32*32-1
 334      arr(i) = i
 335   end do
 336
 337   !$acc parallel copy(arr) num_gangs(32) num_workers(8) vector_length(32)
 338   !$acc loop gang ! { dg-line l_loop[incr c_loop] }
 339   ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 340   do i = 0, 31
 341      !$acc loop worker private(x) ! { dg-line l_loop[incr c_loop] }
 342      ! { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 343      ! { dg-note {variable 'x' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 344      do j = 0, 31
 345         x = ieor(i, j * 3)
 346
 347         !$acc loop vector ! { dg-line l_loop[incr c_loop] }
 348         ! { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 349         do k = 0, 31
 350            arr(i * 1024 + j * 32 + k) = arr(i * 1024 + j * 32 + k) + x * k
 351         end do
 352      end do
 353
 354      !$acc loop worker private(x) ! { dg-line l_loop[incr c_loop] }
 355      ! { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 356      ! { dg-note {variable 'x' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 357      do j = 0, 31
 358         x = ior(i, j * 5)
 359
 360         !$acc loop vector ! { dg-line l_loop[incr c_loop] }
 361         ! { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 362         do k = 0, 31
 363            arr(i * 1024 + j * 32 + k) = arr(i * 1024 + j * 32 + k) + x * k
 364         end do
 365      end do
 366   end do
 367   !$acc end parallel
 368
 369   do i = 0, 32 - 1
 370      do j = 0, 32 -1
 371         do k = 0, 32 - 1
 372            idx = i * 1024 + j * 32 + k
 373            if (arr(idx) .ne. idx + ieor(i, j * 3) * k + ior(i, j * 5) * k) then
 374               STOP 9
 375            end if
 376         end do
 377      end do
 378   end do
 379 end subroutine t9
 380
 381
 382 ! Test of worker-private variables declared on a loop directive, broadcasting
 383 ! to vector-partitioned mode.  Successive vector loops.  */
 384
 385 subroutine t10()
 386   integer :: x, i, j, k, idx, arr(0:32*32*32)
 387
 388   do i = 0, 32*32*32-1
 389      arr(i) = i
 390   end do
 391
 392   !$acc parallel copy(arr) num_gangs(32) num_workers(8) vector_length(32)
 393   !$acc loop gang ! { dg-line l_loop[incr c_loop] }
 394   ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 395   do i = 0, 31
 396      !$acc loop worker private(x) ! { dg-line l_loop[incr c_loop] }
 397      ! { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 398      ! { dg-note {variable 'x' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 399      do j = 0, 31
 400         x = ieor(i, j * 3)
 401
 402         !$acc loop vector ! { dg-line l_loop[incr c_loop] }
 403         ! { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 404         do k = 0, 31
 405            arr(i * 1024 + j * 32 + k) = arr(i * 1024 + j * 32 + k) + x * k
 406         end do
 407
 408         x = ior(i, j * 5)
 409
 410         !$acc loop vector ! { dg-line l_loop[incr c_loop] }
 411         ! { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 412         do k = 0, 31
 413            arr(i * 1024 + j * 32 + k) = arr(i * 1024 + j * 32 + k) + x * k
 414         end do
 415      end do
 416   end do
 417   !$acc end parallel
 418
 419   do i = 0, 32 - 1
 420      do j = 0, 32 -1
 421         do k = 0, 32 - 1
 422            idx = i * 1024 + j * 32 + k
 423            if (arr(idx) .ne. idx + ieor(i, j * 3) * k + ior(i, j * 5) * k) then
 424               STOP 10
 425            end if
 426         end do
 427      end do
 428   end do
 429 end subroutine t10
 430
 431
 432 ! Test of worker-private variables declared on a loop directive, broadcasting
 433 ! to vector-partitioned mode.  Addressable worker variable.
 434
 435 subroutine t11()
 436   integer :: i, j, k, idx, arr(0:32*32*32)
 437   integer, target :: x
 438   integer, pointer :: p
 439
 440   do i = 0, 32*32*32-1
 441      arr(i) = i
 442   end do
 443
 444   !$acc parallel copy(arr) num_gangs(32) num_workers(8) vector_length(32)
 445   !$acc loop gang ! { dg-line l_loop[incr c_loop] }
 446   ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 447   do i = 0, 31
 448      !$acc loop worker private(x, p) ! { dg-line l_loop[incr c_loop] }
 449      ! { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 450      ! { dg-note {variable 'x' in 'private' clause is candidate for adjusting OpenACC privatization level} "" { target *-*-* } l_loop$c_loop }
 451      ! { dg-note {variable 'x' ought to be adjusted for OpenACC privatization level: 'worker'} "" { target *-*-* } l_loop$c_loop }
 452      ! { dg-note {variable 'x' adjusted for OpenACC privatization level: 'worker'} "TODO" { target { ! openacc_host_selected } xfail *-*-* } l_loop$c_loop }
 453      ! { dg-note {variable 'p' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 454      do j = 0, 31
 455         p => x
 456         x = ieor(i, j * 3)
 457
 458         !$acc loop vector ! { dg-line l_loop[incr c_loop] }
 459         ! { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 460         do k = 0, 31
 461            arr(i * 1024 + j * 32 + k) = arr(i * 1024 + j * 32 + k) + x * k
 462         end do
 463
 464         p = ior(i, j * 5)
 465
 466         !$acc loop vector ! { dg-line l_loop[incr c_loop] }
 467         ! { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 468         do k = 0, 31
 469            arr(i * 1024 + j * 32 + k) = arr(i * 1024 + j * 32 + k) + x * k
 470         end do
 471      end do
 472   end do
 473   !$acc end parallel
 474
 475   do i = 0, 32 - 1
 476      do j = 0, 32 -1
 477         do k = 0, 32 - 1
 478            idx = i * 1024 + j * 32 + k
 479            if (arr(idx) .ne. idx + ieor(i, j * 3) * k + ior(i, j * 5) * k) then
 480               STOP 11
 481            end if
 482         end do
 483      end do
 484   end do
 485 end subroutine t11
 486
 487
 488 ! Test of worker-private variables declared on a loop directive, broadcasting
 489 ! to vector-partitioned mode.  Aggregate worker variable.
 490
 491 subroutine t12()
 492   type vec2
 493      integer x, y
 494   end type vec2
 495
 496   integer :: i, j, k, idx, arr(0:32*32*32)
 497   type(vec2) :: pt
 498
 499   do i = 0, 32*32*32-1
 500      arr(i) = i
 501   end do
 502
 503   !$acc parallel copy(arr) num_gangs(32) num_workers(8) vector_length(32)
 504   !$acc loop gang ! { dg-line l_loop[incr c_loop] }
 505   ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 506   do i = 0, 31
 507      !$acc loop worker private(pt) ! { dg-line l_loop[incr c_loop] }
 508      ! { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 509      ! { dg-note {variable 'pt' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 510      do j = 0, 31
 511         pt%x = ieor(i, j * 3)
 512         pt%y = ior(i, j * 5)
 513
 514         !$acc loop vector ! { dg-line l_loop[incr c_loop] }
 515         ! { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 516         do k = 0, 31
 517            arr(i * 1024 + j * 32 + k) = arr(i * 1024 + j * 32 + k) + pt%x * k
 518         end do
 519
 520         !$acc loop vector ! { dg-line l_loop[incr c_loop] }
 521         ! { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 522         do k = 0, 31
 523            arr(i * 1024 + j * 32 + k) = arr(i * 1024 + j * 32 + k) + pt%y * k
 524         end do
 525      end do
 526   end do
 527   !$acc end parallel
 528
 529   do i = 0, 32 - 1
 530      do j = 0, 32 -1
 531         do k = 0, 32 - 1
 532            idx = i * 1024 + j * 32 + k
 533            if (arr(idx) .ne. idx + ieor(i, j * 3) * k + ior(i, j * 5) * k) then
 534               STOP 12
 535            end if
 536         end do
 537      end do
 538   end do
 539 end subroutine t12
 540
 541
 542 ! Test of worker-private variables declared on loop directive, broadcasting
 543 ! to vector-partitioned mode.  Array worker variable.
 544
 545 subroutine t13()
 546   integer :: i, j, k, idx, arr(0:32*32*32), pt(2)
 547
 548   do i = 0, 32*32*32-1
 549      arr(i) = i
 550   end do
 551
 552   !$acc parallel copy(arr) num_gangs(32) num_workers(8) vector_length(32)
 553   !$acc loop gang ! { dg-line l_loop[incr c_loop] }
 554   ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 555   do i = 0, 31
 556      !$acc loop worker private(pt) ! { dg-line l_loop[incr c_loop] }
 557      ! { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 558      ! { dg-note {variable 'pt' in 'private' clause is candidate for adjusting OpenACC privatization level} "" { target *-*-* } l_loop$c_loop }
 559      ! { dg-note {variable 'pt' ought to be adjusted for OpenACC privatization level: 'worker'} "" { target *-*-* } l_loop$c_loop }
 560      ! { dg-note {variable 'pt' adjusted for OpenACC privatization level: 'worker'} "TODO" { target { ! openacc_host_selected } xfail *-*-* } l_loop$c_loop } */
 561      do j = 0, 31
 562         pt(1) = ieor(i, j * 3)
 563         pt(2) = ior(i, j * 5)
 564
 565         !$acc loop vector ! { dg-line l_loop[incr c_loop] }
 566         ! { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 567         do k = 0, 31
 568            arr(i * 1024 + j * 32 + k) = arr(i * 1024 + j * 32 + k) + pt(1) * k
 569         end do
 570
 571         !$acc loop vector ! { dg-line l_loop[incr c_loop] }
 572         ! { dg-note {variable 'k' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 573         do k = 0, 31
 574            arr(i * 1024 + j * 32 + k) = arr(i * 1024 + j * 32 + k) + pt(2) * k
 575         end do
 576      end do
 577   end do
 578   !$acc end parallel
 579
 580   do i = 0, 32 - 1
 581      do j = 0, 32 -1
 582         do k = 0, 32 - 1
 583            idx = i * 1024 + j * 32 + k
 584            if (arr(idx) .ne. idx + ieor(i, j * 3) * k + ior(i, j * 5) * k) then
 585               STOP 13
 586            end if
 587         end do
 588      end do
 589   end do
 590 end subroutine t13
 591
 592
 593 ! Test of gang-private variables declared on the parallel directive.
 594
 595 subroutine t14()
 596   use openacc
 597   integer :: x = 5
 598   integer, parameter :: n = 32
 599   integer :: arr(n)
 600
 601   do i = 1, n
 602     arr(i) = 3
 603   end do
 604
 605   !$acc parallel private(x) copy(arr) num_gangs(n) num_workers(8) vector_length(32)
 606   ! { dg-warning "region is worker partitioned but does not contain worker partitioned code" "" { target *-*-* } .-1 }
 607   ! { dg-warning "region is vector partitioned but does not contain vector partitioned code" "" { target *-*-* } .-2 }
 608     !$acc loop gang(static:1) ! { dg-line l_loop[incr c_loop] }
 609     ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 610     do i = 1, n
 611       x = i * 2;
 612     end do
 613
 614    !$acc loop gang(static:1) ! { dg-line l_loop[incr c_loop] }
 615     ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop }
 616     do i = 1, n
 617        ! { dg-note {variable 'C\.[0-9]+' declared in block potentially has improper OpenACC privatization level: 'const_decl'} "TODO" { target *-*-* } l_loop$c_loop }
 618        !TODO Unhandled 'CONST_DECL' instance for constant argument in 'acc_on_device' call.
 619       if (acc_on_device (acc_device_host) .eqv. .TRUE.) x = i * 2
 620       arr(i) = arr(i) + x
 621     end do
 622   !$acc end parallel
 623
 624   do i = 1, n
 625     if (arr(i) .ne. (3 + i * 2)) STOP 14
 626   end do
 627
 628 end subroutine t14
 629
 630
 631 program main
 632   call t1()
 633   call t2()
 634   call t3()
 635   call t4()
 636   call t5()
 637   call t6()
 638   call t7()
 639   call t8()
 640   call t9()
 641   call t10()
 642   call t11()
 643   call t12()
 644   call t13()
 645   call t14()
 646 end program main