offtarget 0.1.0__py3-none-any.whl

offload/_root/data/findings/fuzz/b3-250-cce20.f90

@@ -0,0 +1,89 @@
+! Minimized by compliance.fuzz_min from fuzz seed 250 (fuzz-3).
+! toolchain: cce20 (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: wrong_code
+! expected: the host reference checksum (host reference (elision) checksum=1218074569)
+! observed: device checksum=1312631914 ran_on_host=0
+! Legal OpenMP 5.2: offload.engine.prerun.check accepts it (rerun: offload.engine.rules with the
+!   race rule and the restriction checks, and the AFAR flang front end, not under test here); no
+!   compiler under test, gfortran or gcc is a legality witness.
+! also fails on: cce19, cce21
+module fuzz_mod
+  implicit none
+contains
+end module fuzz_mod
+program fuzz_prog
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 128, m = 5
+  type :: rec_t
+  end type rec_t
+  type(rec_t) :: dr
+  integer :: ia(n)
+  integer, allocatable :: ib(:)
+  integer, allocatable :: ic(:, :)
+  integer, allocatable :: o1(:)
+  integer, pointer :: o2(:)
+  integer, target :: o2t(n)
+  integer :: i, j, p1, r1a, hf1
+  integer(8) :: cs
+  allocate(ib(n))
+  allocate(ic(n, m))
+  allocate(o1(n))
+  o2 => o2t
+  do i = 1, n
+    ia(i) = mod(i * 35 + 30, 1009) - 462
+  end do
+  do i = 1, n
+    ib(i) = mod(i * 22 + 36, 30011) - 8252
+  end do
+  do j = 1, m
+    do i = 1, n
+      ic(i, j) = mod((i + 6 * j) * 36 + 12, 30011) - 539
+    end do
+  end do
+  o1 = 0
+  o2 = 0
+  p1 = -6
+  r1a = -5
+  hf1 = 0
+  ! fuzz: kernels
+  call kp1(ia, ib, ic, o1, dr, p1)
+  ! fuzz: checksum
+  cs = 0
+  cs = modulo(cs * 31_8 + int(r1a, 8), 2147483629_8)
+  do i = 1, n
+    cs = modulo(cs * 31_8 + int(o1(i), 8), 2147483629_8)
+  end do
+  do i = 1, n
+    cs = modulo(cs * 31_8 + int(o2t(i), 8), 2147483629_8)
+  end do
+  print '(a,i0,a,i0)', 'RESULT checksum=', cs, ' ran_on_host=', max(hf1, 0)
+contains
+  subroutine kp1(ia, ib, ic, o1, dr, p1)
+    integer, intent(in) :: ia(:)
+    integer, intent(inout) :: ib(:)
+    integer, intent(inout) :: ic(:, :)
+    integer, intent(inout) :: o1(:)
+    type(rec_t), intent(inout) :: dr
+    integer, intent(in) :: p1
+    !$omp taskgroup task_reduction(+: r1a)
+      !$omp target map(tofrom: hf1) in_reduction(+: r1a)
+        hf1 = merge(1, 0, omp_is_initial_device())
+        do i = 1, n
+          o1(i) = 1009
+        end do
+      !$omp end target
+    !$omp end taskgroup
+  end subroutine kp1
+  subroutine kp2(ib, ic, o2, dr, zopt)
+    integer, allocatable, intent(inout) :: ib(:)
+    integer, intent(in) :: ic(:, :)
+    integer, pointer, intent(in) :: o2(:)
+    type(rec_t), intent(inout) :: dr
+    integer, intent(in), optional :: zopt(:)
+  end subroutine kp2
+end program fuzz_prog
+! site:
+! title: ftn: a target construct with in_reduction in an internal subroutine loses the writes to an implicitly mapped dummy array
+! same_as: fuzz/b3-61-cce20
+! end site

offload/_root/data/findings/fuzz/b3-278-cce19.f90

@@ -0,0 +1,70 @@
+! Minimized by compliance.fuzz_min from fuzz seed 278 (fuzz-3).
+! toolchain: cce19 (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: run_error (crash: SIGABRT)
+! expected: runs to completion (the host run does)
+! observed: device: fail crash: SIGABRT; host reference (afar) checksum=144
+! Legal OpenMP 5.2: offload.engine.prerun.check accepts it (rerun: offload.engine.rules with the
+!   race rule and the restriction checks, and the AFAR flang front end, not under test here); no
+!   compiler under test, gfortran or gcc is a legality witness.
+! also failed on (before refinement): cce20
+! : CCE 21.0.3 and 21.0.4 fail it too (hipErrorIllegalAddress, HSA_XNACK 0
+!   and 1; reruns); it was recorded as correct on CCE 21.
+program fuzz_prog
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 64, m = 5
+  type :: rec_t
+    integer, allocatable :: q(:)
+  end type rec_t
+  type(rec_t) :: dr
+  integer, allocatable, target :: ib(:)
+  integer :: ic(n, m)
+  integer :: i, j, r1b
+  integer(8) :: cs
+  allocate(ib(n))
+  allocate(dr%q(n))
+  do i = 1, n
+    ib(i) = mod(i * 42 + 15, 101) - 28
+  end do
+  do j = 1, m
+    do i = 1, n
+      ic(i, j) = mod((i + 6 * j) * 19 + 21, 97) - 20
+    end do
+  end do
+  do i = 1, n
+    dr%q(i) = mod(i * 17 + 13, 1009) - 449
+  end do
+  r1b = -13
+  ! fuzz: kernels
+    !$omp target teams reduction(max: r1b)
+      !$omp distribute
+      do i = n, 1, -1
+        do j = 1, m
+          r1b = max(r1b, max((dr%q(i) / 8), (ic(8, (6 - j)) + ib(i))))
+        end do
+      end do
+      !$omp end distribute
+    !$omp end target teams
+  ! fuzz: checksum
+  cs = 0
+  cs = modulo(cs * 31_8 + int(r1b, 8), 2147483629_8)
+  print '(a,i0,a,i0)', 'RESULT checksum=', cs, ' ran_on_host=', 0
+end program fuzz_prog
+! site:
+! title: ftn: target teams with reduction(max) reading an allocatable component of an implicitly mapped structure ends in an illegal
+! + memory access
+! control: ../vendor/checks/src/fuzz/control/fuzz-b3-278-cce19-control.f90 the device loop reads ib(i) instead of the allocatable
+! + component
+! + dr%q(i) (dr is not referenced in the region)
+! end site
+! spec (requirement): a structure variable that a target region references, with no clause naming it, is mapped tofrom with each
+!   structure element (an allocatable component included), and a reduction on a combined target teams construct is combined into
+!   the original list item.
+! "A structure type T has a predefined default mapper that is defined as if by a declare mapper directive that specifies v in a
+!   map clause with the alloc map-type and each structure element of v in a map clause with the tofrom map-type." (5.2 §5.8.2
+!   p.150 l.2-4)
+! "If a variable is not a scalar then it is treated as if it had appeared in a map clause with a map-type of tofrom." (5.2
+!   §5.8.1 p.149 l.4-5)
+! spec (this program): target teams reduction(max: r1b) reads the allocatable component dr%q(i) of the implicitly mapped
+!   structure dr in the distribute loop; the component is mapped with the structure, but CCE 19, 20 and 21 end in an illegal
+!   memory access, and the program is correct when the loop reads ib(i) instead.

offload/_root/data/findings/fuzz/b3-45-cce21.f90

@@ -0,0 +1,83 @@
+! Minimized by compliance.fuzz_min from fuzz seed 45 (fuzz-3).
+! toolchain: cce21 (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: run_error (crash: SIGSEGV)
+! expected: runs to completion (the host run does)
+! observed: device: fail crash: SIGSEGV; host reference (elision) checksum=0
+! Legal OpenMP 5.2: offload.engine.prerun.check accepts it (rerun: offload.engine.rules with the
+!   race rule and the restriction checks, and the AFAR flang front end, not under test here); no
+!   compiler under test, gfortran or gcc is a legality witness.
+! also fails on: afar
+program fuzz_prog
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 64, m = 5
+  type :: rec_t
+  end type rec_t
+  type(rec_t) :: dr
+  integer :: ib(n)
+  integer, allocatable :: ic(:, :)
+  integer, pointer :: o1(:)
+  integer :: o2(n, m)
+  integer, target :: o1t(n)
+  integer :: i, j, jj, p2
+  integer(8) :: cs
+  allocate(ic(n, m))
+  o1 => o1t
+  do i = 1, n
+    ib(i) = mod(i * 4 + 15, 1009) - 364
+  end do
+  do j = 1, m
+    do i = 1, n
+      ic(i, j) = mod((i + 8 * j) * 29 + 24, 1009) - 73
+    end do
+  end do
+  o1 = 0
+  o2 = 0
+  p2 = 8
+  ! fuzz: kernels
+  call kp2(ic, o2, dr, p2)
+  ! fuzz: checksum
+  cs = 0
+  do i = 1, n
+    cs = modulo(cs * 31_8 + int(o1t(i), 8), 2147483629_8)
+  end do
+  do j = 1, m
+    do i = 1, n
+      cs = modulo(cs * 31_8 + int(o2(i, j), 8), 2147483629_8)
+    end do
+  end do
+  print '(a,i0,a,i0)', 'RESULT checksum=', cs, ' ran_on_host=', 0
+contains
+  subroutine kp1(ib, ic, o1, dr, p2, zopt)
+    integer, intent(in) :: ib(:)
+    integer, allocatable, intent(in) :: ic(:, :)
+    integer, pointer, intent(in) :: o1(:)
+    type(rec_t), intent(inout) :: dr
+    integer, value :: p2
+    integer, intent(in), optional :: zopt(:)
+    integer :: i, j, jj, acc1
+  end subroutine kp1
+  subroutine kp2(ic, o2, dr, p2, zopt)
+    integer, intent(in) :: ic(:, :)
+    integer, intent(inout) :: o2(:, :)
+    type(rec_t), intent(inout) :: dr
+    integer, intent(in), optional :: p2
+    integer, intent(in), optional :: zopt(:)
+    integer :: i, j, jj, t2
+    !$omp target map(to: zopt)
+    do i = 1, n
+      !$omp parallel
+        !$omp do private(t2)
+        do j = m, 1, -1
+          t2 = 0
+        end do
+        !$omp end do
+      !$omp end parallel
+    end do
+    !$omp end target
+  end subroutine kp2
+end program fuzz_prog
+! site:
+! title: ftn: map(to: zopt) of an absent optional dummy in an internal subroutine crashes the run (SIGSEGV)
+! same_as: fuzz/b3-190-cce21
+! end site

offload/_root/data/findings/fuzz/b3-54-afar.f90

@@ -0,0 +1,67 @@
+! Minimized by compliance.fuzz_min from fuzz seed 54 (fuzz-3).
+! toolchain: afar (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: run_error (crash: SIGSEGV)
+! expected: runs to completion (the host run does)
+! observed: device: fail crash: SIGSEGV; host reference (elision) checksum=0
+! Legal OpenMP 5.2: offload.engine.rules accepts it (offload.engine.prerun.check, rerun: with the
+!   race rule and the restriction checks); nvfortran/nvc 26.9 and 25.11 (NVHPC, not under test
+!   here) compile it; the check's other witness, the AFAR flang front end, is the compiler under
+!   test and is not counted; no gfortran or gcc is a legality witness.
+module fuzz_mod
+  implicit none
+contains
+end module fuzz_mod
+program fuzz_prog
+  use omp_lib, only: omp_get_thread_num, omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 32, m = 5
+  type :: rec_t
+    integer, allocatable :: q(:)
+  end type rec_t
+  type(rec_t) :: dr
+  integer, allocatable, target :: ic(:, :)
+  integer, pointer :: o1(:)
+  integer :: i, j, p1, hf1
+  integer(8) :: cs
+  allocate(ic(n, m))
+  allocate(dr%q(n))
+  allocate(o1(n))
+  do j = 1, m
+    do i = 1, n
+      ic(i, j) = mod((i + 8 * j) * 26 + 35, 97) - 30
+    end do
+  end do
+  do i = 1, n
+    dr%q(i) = mod(i * 6 + 6, 1009) - 171
+  end do
+  o1 = 0
+  p1 = -3
+  hf1 = 0
+  ! fuzz: kernels
+  !$omp target nowait depend(in: p1) depend(inout: dr, hf1, ic, o1)
+  !$omp end target
+  !$omp taskwait
+  ! fuzz: checksum
+  cs = 0
+  do i = 1, n
+    cs = modulo(cs * 31_8 + int(o1(i), 8), 2147483629_8)
+  end do
+  print '(a,i0,a,i0)', 'RESULT checksum=', cs, ' ran_on_host=', max(hf1, 0)
+end program fuzz_prog
+! site:
+! title: amdflang: an empty target nowait with depend(inout:) on a derived-type variable with an allocatable component crashes
+! + (SIGSEGV)
+! control: ../vendor/checks/src/fuzz/control/fuzz-b3-54-afar-control.f90 dr removed from the depend clause
+! end site
+! spec (requirement): a depend clause on a target construct is associated with the target task and derives its dependences from
+!   the storage locations of its list items; a variable of derived type with an allocated allocatable component is a legal list
+!   item.
+! "The target construct generates a target task. The generated task region encloses the target region. If a depend clause is
+!   present, it is associated with the target task. The device clause determines the device on which the target region executes.
+!   If the nowait clause is present," (5.2 §13.8 p.284 l.14-16)
+! "The depend clause enforces additional constraints on the scheduling of tasks. These constraints establish dependences only
+!   between sibling tasks. Task dependences are derived from the task-dependence-type and the list items." (5.2 §15.9.5 p.323
+!   l.16-18)
+! spec (this program): target nowait depend(inout: dr, hf1, ic, o1) with an empty body followed by taskwait is legal, dr being a
+!   derived-type variable with an allocated allocatable component; AFAR crashes (SIGSEGV), and the program is correct when dr is
+!   removed from the depend clause.

offload/_root/data/findings/fuzz/b3-61-cce20.f90

@@ -0,0 +1,100 @@
+! Minimized by compliance.fuzz_min from fuzz seed 61 (fuzz-3).
+! toolchain: cce20 (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: wrong_code
+! expected: the host reference checksum (host reference (elision) checksum=234479309)
+! observed: device checksum=1451519883 ran_on_host=0
+! Legal OpenMP 5.2: offload.engine.prerun.check accepts it (rerun: offload.engine.rules with the
+!   race rule and the restriction checks, and the AFAR flang front end, not under test here); no
+!   compiler under test, gfortran or gcc is a legality witness.
+! also fails on: cce19, cce21
+program fuzz_prog
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 200, m = 3
+  type :: rec_t
+  end type rec_t
+  type(rec_t) :: dr
+  integer, allocatable :: ia(:)
+  integer, allocatable :: ib(:)
+  integer, allocatable :: ic(:, :)
+  integer :: o1(n)
+  integer :: o2(n)
+  integer, allocatable :: o3(:)
+  integer :: i, j, p1, r3a, hf3
+  integer(8) :: cs
+  allocate(ia(n))
+  allocate(ib(n))
+  allocate(ic(n, m))
+  allocate(o3(n))
+  do i = 1, n
+    ia(i) = mod(i * 25 + 45, 97) - 25
+  end do
+  do i = 1, n
+    ib(i) = mod(i * 25 + 39, 211) - 4
+  end do
+  do j = 1, m
+    do i = 1, n
+      ic(i, j) = mod((i + 2 * j) * 60 + 25, 101) - 8
+    end do
+  end do
+  o1 = 0
+  o2 = 0
+  o3 = 0
+  p1 = 6
+  r3a = 45
+  hf3 = 0
+  ! fuzz: kernels
+  call kp2(ib, o1, o2, o3, dr, p1)
+  ! fuzz: checksum
+  cs = 0
+  do i = 1, n
+    cs = modulo(cs * 31_8 + int(o1(i), 8), 2147483629_8)
+  end do
+  do i = 1, n
+    cs = modulo(cs * 31_8 + int(o2(i), 8), 2147483629_8)
+  end do
+  cs = modulo(cs * 31_8 + int(r3a, 8), 2147483629_8)
+  do i = 1, n
+    cs = modulo(cs * 31_8 + int(o3(i), 8), 2147483629_8)
+  end do
+  print '(a,i0,a,i0)', 'RESULT checksum=', cs, ' ran_on_host=', max(hf3, 0)
+contains
+  subroutine kp1(ia, ic, o1, dr)
+    integer, intent(inout) :: ia(n)
+    integer, intent(inout) :: ic(n, m)
+    integer, intent(inout) :: o1(n)
+    type(rec_t), intent(inout) :: dr
+  end subroutine kp1
+  subroutine kp2(ib, o1, o2, o3, dr, p1)
+    integer, intent(inout) :: ib(n)
+    integer, intent(inout) :: o1(n)
+    integer, intent(inout) :: o2(:)
+    integer, intent(inout) :: o3(n)
+    type(rec_t), intent(inout) :: dr
+    integer, value :: p1
+    !$omp taskgroup task_reduction(+: r3a)
+      !$omp target map(tofrom: hf3) in_reduction(+: r3a)
+        hf3 = merge(1, 0, omp_is_initial_device())
+        do i = 1, n
+          o3(i) = 9973
+        end do
+      !$omp end target
+    !$omp end taskgroup
+  end subroutine kp2
+end program fuzz_prog
+! site:
+! title: ftn: a target construct with in_reduction in an internal subroutine loses the writes to an implicitly mapped dummy array
+! control: ../vendor/checks/src/fuzz/control/fuzz-b3-61-cce20-control.f90 the taskgroup/task_reduction and the in_reduction
+! + clause removed
+! end site
+! spec (requirement): an array that a target region references and no clause names is mapped tofrom, and an in_reduction clause
+!   on a target construct maps the reduction list item tofrom with the always modifier, so the writes to the other arrays reach
+!   the host.
+! "If a variable is not a scalar then it is treated as if it had appeared in a map clause with a map-type of tofrom." (5.2
+!   §5.8.1 p.149 l.4-5)
+! "If a variable is the base variable of a list item in an in_reduction clause on a target construct then it is treated as if
+!   the list item had appeared in a map clause with a map-type of tofrom and a map-type-modifier of always." (5.2 §5.8.1 p.148
+!   l.15-17)
+! spec (this program): the target region in an internal subroutine, with in_reduction(+: r3a) and map(tofrom: hf3), stores 9973
+!   in the dummy array o3; CCE 19, 20 and 21 lose those writes (checksum differs from the host's), and the program is correct when
+!   taskgroup, task_reduction and in_reduction are removed.

offload/_root/data/findings/fuzz/b3-9-afar.f90

@@ -0,0 +1,100 @@
+! Minimized by compliance.fuzz_min from fuzz seed 9 (fuzz-3).
+! toolchain: afar (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: ice (afar FIR verification: 'omp.simd' op operand #0 must be variadic of OpenMP-compatible variable type, but got
+!   '!fir.box<!fir.array<?x?xi32>>')
+! expected: compiles
+! observed: internal compiler error: ice: error: verification of lowering to FIR failed
+! Legal OpenMP 5.2: offload.engine.rules accepts it (offload.engine.prerun.check, rerun: with the
+!   race rule and the restriction checks); NVHPC is no witness: it rejects it
+!   (NVFORTRAN-S-0034-Syntax error at or near identifier nontemporal); the
+!   check's other witness, the AFAR flang front end, is the compiler under test and is not counted;
+!   no gfortran or gcc is a legality witness.
+program fuzz_prog
+  use omp_lib, only: omp_get_default_device, omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 200, m = 8
+  type :: rec_t
+    integer :: a(n)
+    integer, allocatable :: q(:)
+    integer, pointer :: pc(:)
+  end type rec_t
+  type(rec_t) :: dr
+  integer, allocatable, target :: ia(:)
+  integer :: ib(n)
+  integer, allocatable :: ic(:, :)
+  integer, pointer :: o1(:, :)
+  integer, pointer :: o2(:)
+  integer, target :: o1t(n, m)
+  integer, target :: o2t(n)
+  integer :: i, j, r1a, r1b, hf1, r2a, dev
+  integer(8) :: cs
+  allocate(ia(n))
+  allocate(ic(n, m))
+  allocate(dr%q(n))
+  o1 => o1t
+  o2 => o2t
+  do i = 1, n
+    ia(i) = mod(i * 4 + 15, 1009) - 376
+  end do
+  do i = 1, n
+    ib(i) = mod(i * 3 + 7, 30011) - 3238
+  end do
+  do j = 1, m
+    do i = 1, n
+      ic(i, j) = mod((i + 1 * j) * 60 + 5, 101) - 34
+    end do
+  end do
+  do i = 1, n
+    dr%a(i) = mod(i * 35 + 38, 97) - 36
+    dr%q(i) = mod(i * 10 + 45, 211) - 86
+  end do
+  o1 = 0
+  o2 = 0
+  r1a = 2
+  r1b = 3
+  hf1 = 0
+  r2a = 4
+  dev = omp_get_default_device()
+  ! fuzz: kernels
+  ! fuzz: checksum
+  cs = 0
+  cs = modulo(cs * 31_8 + int(r1a, 8), 2147483629_8)
+  cs = modulo(cs * 31_8 + int(r1b, 8), 2147483629_8)
+  do j = 1, m
+    do i = 1, n
+      cs = modulo(cs * 31_8 + int(o1t(i, j), 8), 2147483629_8)
+    end do
+  end do
+  cs = modulo(cs * 31_8 + int(r2a, 8), 2147483629_8)
+  do i = 1, n
+    cs = modulo(cs * 31_8 + int(o2t(i), 8), 2147483629_8)
+  end do
+  print '(a,i0,a,i0)', 'RESULT checksum=', cs, ' ran_on_host=', max(hf1, 0)
+contains
+  subroutine kp1(ib, o1, dr, zopt)
+    integer, intent(in) :: ib(n)
+    integer, intent(inout) :: o1(:, :)
+    type(rec_t), intent(inout) :: dr
+    integer, intent(in), optional :: zopt(:)
+    !$omp target
+    do i = n, 1, -1
+      !$omp simd nontemporal(o1)
+      do j = m, 1, -1
+      end do
+      !$omp end simd
+    end do
+    !$omp end target
+  end subroutine kp1
+  subroutine kp2(ia, ib, ic, o2, dr, zopt)
+    integer, allocatable, intent(inout) :: ia(:)
+    integer, intent(in) :: ib(n)
+    integer, allocatable, intent(inout) :: ic(:, :)
+    integer, intent(inout) :: o2(:)
+    type(rec_t), intent(inout) :: dr
+    integer, intent(in), optional :: zopt(:)
+  end subroutine kp2
+end program fuzz_prog
+! site:
+! title: amdflang: "verification of lowering to FIR failed" for nontemporal on an assumed-shape dummy
+! same_as: afar-nontemporal-assumed-shape-ice
+! end site

offload/_root/data/findings/fuzz/b3-9-cce21.f90

@@ -0,0 +1,103 @@
+! Minimized by compliance.fuzz_min from fuzz seed 9 (fuzz-3).
+! toolchain: cce21 (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: run_error (crash: SIGSEGV)
+! expected: runs to completion (the host run does)
+! observed: device: fail crash: SIGSEGV; host reference (elision) checksum=185626446
+! Legal OpenMP 5.2: offload.engine.prerun.check accepts it (rerun: offload.engine.rules with the
+!   race rule and the restriction checks, and the AFAR flang front end, not under test here); no
+!   compiler under test, gfortran or gcc is a legality witness.
+! also fails on: afar
+program fuzz_prog
+  use omp_lib, only: omp_get_default_device, omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 200, m = 8
+  type :: rec_t
+    integer :: a(n)
+    integer, allocatable :: q(:)
+    integer, pointer :: pc(:)
+  end type rec_t
+  type(rec_t) :: dr
+  integer, allocatable, target :: ia(:)
+  integer :: ib(n)
+  integer, allocatable :: ic(:, :)
+  integer, pointer :: o1(:, :)
+  integer, pointer :: o2(:)
+  integer, target :: o1t(n, m)
+  integer, target :: o2t(n)
+  integer, target :: tgc(n)
+  integer :: i, j, jj, p1, p2, r1a, r1b, hf1, r2a, dev
+  integer(8) :: cs
+  allocate(ia(n))
+  allocate(ic(n, m))
+  allocate(dr%q(n))
+  dr%pc => tgc
+  o1 => o1t
+  o2 => o2t
+  do i = 1, n
+    ia(i) = mod(i * 4 + 15, 1009) - 376
+  end do
+  do i = 1, n
+    ib(i) = mod(i * 3 + 7, 30011) - 3238
+  end do
+  do j = 1, m
+    do i = 1, n
+      ic(i, j) = mod((i + 1 * j) * 60 + 5, 101) - 34
+    end do
+  end do
+  do i = 1, n
+    dr%a(i) = mod(i * 35 + 38, 97) - 36
+    dr%q(i) = mod(i * 10 + 45, 211) - 86
+    tgc(i) = mod(i * 53 + 43, 1009) - 396
+  end do
+  o1 = 0
+  o2 = 0
+  p1 = -7
+  p2 = 9
+  r1a = 2
+  r1b = 3
+  hf1 = 0
+  r2a = 4
+  dev = omp_get_default_device()
+  ! fuzz: kernels
+  call kp2(ia, ib, ic, o2, dr)
+  ! fuzz: checksum
+  cs = 0
+  cs = modulo(cs * 31_8 + int(r1a, 8), 2147483629_8)
+  cs = modulo(cs * 31_8 + int(r1b, 8), 2147483629_8)
+  do j = 1, m
+    do i = 1, n
+      cs = modulo(cs * 31_8 + int(o1t(i, j), 8), 2147483629_8)
+    end do
+  end do
+  cs = modulo(cs * 31_8 + int(r2a, 8), 2147483629_8)
+  do i = 1, n
+    cs = modulo(cs * 31_8 + int(o2t(i), 8), 2147483629_8)
+  end do
+  print '(a,i0,a,i0)', 'RESULT checksum=', cs, ' ran_on_host=', max(hf1, 0)
+contains
+  subroutine kp1(ib, o1, dr, zopt)
+    integer, intent(in) :: ib(n)
+    integer, intent(inout) :: o1(:, :)
+    type(rec_t), intent(inout) :: dr
+    integer, intent(in), optional :: zopt(:)
+    integer :: i, j, jj
+  end subroutine kp1
+  subroutine kp2(ia, ib, ic, o2, dr, zopt)
+    integer, allocatable, intent(inout) :: ia(:)
+    integer, intent(in) :: ib(n)
+    integer, allocatable, intent(inout) :: ic(:, :)
+    integer, intent(inout) :: o2(:)
+    type(rec_t), intent(inout) :: dr
+    integer, intent(in), optional :: zopt(:)
+    integer :: i, j, jj
+    !$omp target map(to: zopt)
+      !$omp teams loop num_teams(64)
+      do i = 1, n
+      end do
+    !$omp end target
+  end subroutine kp2
+end program fuzz_prog
+! site:
+! title: ftn: map(to: zopt) of an absent optional dummy in an internal subroutine crashes the run (SIGSEGV)
+! same_as: fuzz/b3-190-cce21
+! end site

offload/_root/data/findings/fuzz/b3-94-afar.f90

@@ -0,0 +1,80 @@
+! Minimized by compliance.fuzz_min from fuzz seed 94 (fuzz-3).
+! toolchain: afar (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: wrong_code
+! expected: the host reference checksum (host reference (elision) checksum=2012829416)
+! observed: device checksum=0 ran_on_host=0
+! Legal OpenMP 5.2: offload.engine.rules accepts it (offload.engine.prerun.check, rerun: with the
+!   race rule and the restriction checks); nvfortran/nvc 26.9 and 25.11 (NVHPC, not under test
+!   here) compile it; the check's other witness, the AFAR flang front end, is the compiler under
+!   test and is not counted; no gfortran or gcc is a legality witness.
+module fuzz_mod
+  implicit none
+contains
+end module fuzz_mod
+program fuzz_prog
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 32, m = 2
+  type :: rec_t
+    integer :: a(n)
+    integer, allocatable :: q(:)
+  end type rec_t
+  type(rec_t) :: dr
+  integer, allocatable :: ib(:)
+  integer, allocatable :: o1(:, :)
+  integer, pointer :: o2(:, :)
+  integer :: s3(n)
+  integer, allocatable :: s4(:)
+  integer, target :: o2t(n, m)
+  integer, target :: tgc(n)
+  integer :: i, j
+  integer(8) :: cs
+  allocate(ib(n))
+  allocate(o1(n, m))
+  allocate(s4(n))
+  allocate(dr%q(n))
+  o2 => o2t
+  do i = 1, n
+    ib(i) = mod(i * 16 + 35, 30011) - 1727
+  end do
+  do i = 1, n
+    dr%a(i) = mod(i * 5 + 17, 211) - 48
+    dr%q(i) = mod(i * 50 + 39, 1009) - 500
+    tgc(i) = mod(i * 55 + 22, 97) - 32
+  end do
+  o1 = 0
+  o2 = 0
+  s3 = 0
+  s4 = 0
+  ! fuzz: kernels
+  !$omp target map(to: dr%a, ib)
+    !$omp teams
+      !$omp distribute
+      do i = n, 1, -1
+        !$omp parallel firstprivate(i)
+          !$omp do
+          do j = 1, m
+            o1(i, j) = mod(mod(i, 13), 1009)
+          end do
+        !$omp end parallel
+      end do
+    !$omp end teams
+  !$omp end target
+  ! fuzz: checksum
+  cs = 0
+  do j = 1, m
+    do i = 1, n
+      cs = modulo(cs * 31_8 + int(o1(i, j), 8), 2147483629_8)
+    end do
+  end do
+  do j = 1, m
+    do i = 1, n
+      cs = modulo(cs * 31_8 + int(o2t(i, j), 8), 2147483629_8)
+    end do
+  end do
+  print '(a,i0,a,i0)', 'RESULT checksum=', cs, ' ran_on_host=', 0
+end program fuzz_prog
+! site:
+! title: amdflang: a parallel region with firstprivate nested in a distribute loop loses the writes of its worksharing loop
+! same_as: fuzz/650-afar
+! end site